mediacontrolview.cpp

VLC媒体播放程序

/*****************************************************************************
 * SeekSlider::MouseMoved
 *****************************************************************************/
void
SeekSlider::MouseMoved(BPoint where, uint32 code, const BMessage* dragMessage)
{
	if (fTracking)
	{
		SetValue(_ValueFor(where.x));
		_Seek();
	}
}

/*****************************************************************************
 * SeekSlider::MouseUp
 *****************************************************************************/
void
SeekSlider::MouseUp(BPoint where)
{
	if (fTracking)
	{
		fTracking = false;
		_EndSeek();
	}
}

/*****************************************************************************
 * SeekSlider::ResizeToPreferred
 *****************************************************************************/
void
SeekSlider::ResizeToPreferred()
{
	float width = 15.0 + StringWidth(DISABLED_SEEK_MESSAGE) + 15.0;
	ResizeTo(width, 17.0);
}

/*****************************************************************************
 * SeekSlider::SetPosition
 *****************************************************************************/
void
SeekSlider::SetPosition(float position)
{
	if ( LockLooper() )
	{
		SetValue(fMinValue + (int32)floorf((fMaxValue - fMinValue) * position + 0.5));
		UnlockLooper();
	}
}

/*****************************************************************************
 * SeekSlider::_ValueFor
 *****************************************************************************/
int32
SeekSlider::_ValueFor(float xPos) const
{
	BRect r(Bounds());
	float knobWidth2 = SEEK_SLIDER_KNOB_WIDTH / 2.0;
	float sliderStart = (r.left + knobWidth2);
	float sliderEnd = (r.right - knobWidth2);
	int32 value =  fMinValue + (int32)(((xPos - sliderStart) * (fMaxValue - fMinValue))
				  / (sliderEnd - sliderStart - 1.0));
	if (value < fMinValue)
		value = fMinValue;
	if (value > fMaxValue)
		value = fMaxValue;
	return value;
}

/*****************************************************************************
 * SeekSlider::_StrokeFrame
 *****************************************************************************/
void
SeekSlider::_StrokeFrame(BRect r, rgb_color left, rgb_color top,
						 rgb_color right, rgb_color bottom)
{
	BeginLineArray(4);
		AddLine(BPoint(r.left, r.bottom), BPoint(r.left, r.top), left);
		AddLine(BPoint(r.left + 1.0, r.top), BPoint(r.right, r.top), top);
		AddLine(BPoint(r.right, r.top + 1.0), BPoint(r.right, r.bottom), right);
		AddLine(BPoint(r.right - 1.0, r.bottom), BPoint(r.left + 1.0, r.bottom), bottom);
	EndLineArray();
}

/*****************************************************************************
 * SeekSlider::_BeginSeek
 *****************************************************************************/
void
SeekSlider::_BeginSeek()
{
	fOwner->fScrubSem = create_sem(0, "Vlc::fScrubSem");
	if (fOwner->fScrubSem >= B_OK)
		release_sem(fOwner->fScrubSem);
}

/*****************************************************************************
 * SeekSlider::_Seek
 *****************************************************************************/
void
SeekSlider::_Seek()
{
	if (fOwner->fScrubSem >= B_OK)
		delete_sem(fOwner->fScrubSem);
	fOwner->fScrubSem = create_sem(0, "Vlc::fScrubSem");
	if (fOwner->fScrubSem >= B_OK)
		release_sem(fOwner->fScrubSem);
}

/*****************************************************************************
 * SeekSlider::_EndSeek
 *****************************************************************************/
void
SeekSlider::_EndSeek()
{
	if (fOwner->fScrubSem >= B_OK)
		delete_sem(fOwner->fScrubSem);
	fOwner->fScrubSem = B_ERROR;
}


/*****************************************************************************
 * VolumeSlider
 *****************************************************************************/
VolumeSlider::VolumeSlider(BRect frame, const char* name, int32 minValue, int32 maxValue,
						   BMessage* message, BHandler* target)
	: BControl(frame, name, NULL, message, B_FOLLOW_NONE,
			   B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE),
	  fLeftSideBits(NULL),
	  fRightSideBits(NULL),
	  fKnobBits(NULL),
	  fTracking(false),
	  fMuted(false),
	  fMinValue(minValue),
	  fMaxValue(maxValue)
{
	SetTarget(target);

	// create bitmaps
	BRect r(BPoint(0.0, 0.0), kVolumeSliderBitmapSize);
	fLeftSideBits = new BBitmap(r, B_CMAP8);
	fRightSideBits = new BBitmap(r, B_CMAP8);
	r.Set(0.0, 0.0, kVolumeSliderKnobBitmapSize.x, kVolumeSliderKnobBitmapSize.y);
	fKnobBits = new BBitmap(r, B_CMAP8);

	_MakeBitmaps();
}

/*****************************************************************************
 * VolumeSlider destructor
 *****************************************************************************/
VolumeSlider::~VolumeSlider()
{
	delete fLeftSideBits;
	delete fRightSideBits;
	delete fKnobBits;
}

/*****************************************************************************
 * VolumeSlider::AttachedToWindow
 *****************************************************************************/
void
VolumeSlider::AttachedToWindow()
{
	BControl::AttachedToWindow();
	SetViewColor(B_TRANSPARENT_32_BIT);
}

/*****************************************************************************
 * VolumeSlider::SetValue
 *****************************************************************************/
void
VolumeSlider::SetValue(int32 value)
{
	if (value != Value())
	{
		BControl::SetValue(value);
		Invoke();
	}
}

/*****************************************************************************
 * VolumeSlider::SetEnabled
 *****************************************************************************/
void
VolumeSlider::SetEnabled(bool enable)
{
	if (enable != IsEnabled())
	{
		BControl::SetEnabled(enable);
		_MakeBitmaps();
		Invalidate();
	}
}

/*****************************************************************************
 * VolumeSlider::Draw
 *****************************************************************************/
void
VolumeSlider::Draw(BRect updateRect)
{
	if (IsValid())
	{
		BRect r(Bounds());
		float sliderSideWidth = kVolumeSliderBitmapWidth;
		float sliderStart = (r.left + sliderSideWidth);
		float sliderEnd = (r.right - sliderSideWidth);
		float knobPos = sliderStart
						+ (sliderEnd - sliderStart - 1.0) * (Value() - fMinValue)
						/ (fMaxValue - fMinValue);
		// draw both sides (the original from Be doesn't seem
		// to make a difference for enabled/disabled state)
		DrawBitmapAsync(fLeftSideBits, r.LeftTop());
		DrawBitmapAsync(fRightSideBits, BPoint(sliderEnd + 1.0, r.top));
		// colors for the slider area between the two bitmaps
		rgb_color background = kBackground;//ui_color(B_PANEL_BACKGROUND_COLOR);
		rgb_color shadow = tint_color(background, B_DARKEN_2_TINT);
		rgb_color softShadow = tint_color(background, B_DARKEN_1_TINT);
		rgb_color darkShadow = tint_color(background, B_DARKEN_4_TINT);
		rgb_color midShadow = tint_color(background, B_DARKEN_3_TINT);
		rgb_color light = tint_color(background, B_LIGHTEN_MAX_TINT);
		rgb_color softLight = tint_color(background, B_LIGHTEN_1_TINT);
		rgb_color green = kGreen;
		rgb_color greenShadow = kGreenShadow;
		rgb_color black = kBlack;
		rgb_color dotGrey = midShadow;
		rgb_color dotGreen = greenShadow;
		// make dimmed version of colors if we're disabled
		if (!IsEnabled())
		{
			shadow = (rgb_color){ 200, 200, 200, 255 };
			softShadow = dimmed_color_cmap8(softShadow, background, DIM_LEVEL);
			darkShadow = dimmed_color_cmap8(darkShadow, background, DIM_LEVEL);
			midShadow = shadow;
			light = dimmed_color_cmap8(light, background, DIM_LEVEL);
			softLight = dimmed_color_cmap8(softLight, background, DIM_LEVEL);
			green = dimmed_color_cmap8(green, background, DIM_LEVEL);
			greenShadow = dimmed_color_cmap8(greenShadow, background, DIM_LEVEL);
			black = dimmed_color_cmap8(black, background, DIM_LEVEL);
			dotGreen = dotGrey;
		}
		else if (fMuted)
		{
			green = tint_color(kBackground, B_DARKEN_3_TINT);
			greenShadow = tint_color(kBackground, B_DARKEN_4_TINT);
			dotGreen = greenShadow;
		}
		// draw slider edges between bitmaps
		BeginLineArray(7);
			AddLine(BPoint(sliderStart, r.top),
					BPoint(sliderEnd, r.top), softShadow);
			AddLine(BPoint(sliderStart, r.bottom),
					BPoint(sliderEnd, r.bottom), softLight);
			r.InsetBy(0.0, 1.0);
			AddLine(BPoint(sliderStart, r.top),
					BPoint(sliderEnd, r.top), black);
			AddLine(BPoint(sliderStart, r.bottom),
					BPoint(sliderEnd, r.bottom), light);
			r.top++;
			AddLine(BPoint(sliderStart, r.top),
					BPoint(knobPos, r.top), greenShadow);
			AddLine(BPoint(knobPos, r.top),
					BPoint(sliderEnd, r.top), midShadow);
			r.top++;
			AddLine(BPoint(sliderStart, r.top),
					BPoint(knobPos, r.top), greenShadow);
		EndLineArray();
		// fill rest inside of slider
		r.InsetBy(0.0, 1.0);
		r.left = sliderStart;
		r.right = knobPos;
		SetHighColor(green);
		FillRect(r, B_SOLID_HIGH);
		r.left = knobPos + 1.0;
		r.right = sliderEnd;
		r.top -= 1.0;
		SetHighColor(shadow);
		FillRect(r, B_SOLID_HIGH);
		// draw little dots inside
		int32 dotCount = (int32)((sliderEnd - sliderStart) / 5.0);
		BPoint dotPos;
		dotPos.y = r.top + 4.0;
		for (int32 i = 0; i < dotCount; i++)
		{
			dotPos.x = sliderStart + i * 5.0 + 4.0;
			SetHighColor(dotPos.x < knobPos ? dotGreen : dotGrey);
			StrokeLine(dotPos, BPoint(dotPos.x, dotPos.y + 1.0));
		}
		// draw knob
		r.top -= 1.0;
		SetDrawingMode(B_OP_OVER); // part of knob is transparent
		DrawBitmapAsync(fKnobBits, BPoint(knobPos - kVolumeSliderKnobWidth / 2, r.top));
	}
}

/*****************************************************************************
 * VolumeSlider::MouseDown
 *****************************************************************************/
void
VolumeSlider::MouseDown(BPoint where)
{
	if (Bounds().Contains(where) && IsEnabled())
	{
		fTracking = true;
		SetValue(_ValueFor(where.x));
		SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
	}
}

/*****************************************************************************
 * VolumeSlider::MouseMoved
 *****************************************************************************/
void
VolumeSlider::MouseMoved(BPoint where, uint32 transit, const BMessage* dragMessage)
{
	if (fTracking)
		SetValue(_ValueFor(where.x));
}

/*****************************************************************************
 * VolumeSlider::MouseUp
 *****************************************************************************/
void
VolumeSlider::MouseUp(BPoint where)
{
	fTracking = false;
}


/*****************************************************************************
 * VolumeSlider::IsValid
 *****************************************************************************/
bool
VolumeSlider::IsValid() const
{
	return (fLeftSideBits && fLeftSideBits->IsValid()
			&& fRightSideBits && fRightSideBits->IsValid()
			&& fKnobBits && fKnobBits->IsValid());
}

/*****************************************************************************
 * VolumeSlider::SetMuted
 *****************************************************************************/
void
VolumeSlider::SetMuted(bool mute)
{
	if (mute != fMuted)
	{
		fMuted = mute;
		_MakeBitmaps();
		Invalidate();
	}
}

/*****************************************************************************
 * VolumeSlider::_MakeBitmaps
 *****************************************************************************/
void
VolumeSlider::_MakeBitmaps()
{
	if (IsValid())
	{
		// left side of slider
		memcpy(fLeftSideBits->Bits(), kVolumeSliderLeftBitmapBits,
			   fLeftSideBits->BitsLength());
		// right side of slider
		memcpy(fRightSideBits->Bits(), kVolumeSliderRightBits,
			   fRightSideBits->BitsLength());
		// slider knob
		int32 length = fKnobBits->BitsLength();