mediacontrolview.cpp

video linux conference

	// add up width of controls along bottom (seek slider will likely adopt)
	float minWidth = 2 * BORDER_INSET;
	minWidth += fSkipBack->Bounds().Width() + MIN_SPACE;
//	minWidth += fRewind->Bounds().Width() + MIN_SPACE;
	minWidth += fStop->Bounds().Width() + MIN_SPACE;
	minWidth += fPlayPause->Bounds().Width() + MIN_SPACE;
//	minWidth += fForward->Bounds().Width() + MIN_SPACE;
	minWidth += fSkipForward->Bounds().Width() + MIN_SPACE + MIN_SPACE;
	minWidth += fMute->Bounds().Width() + SPEAKER_SLIDER_DIST;
	minWidth += VOLUME_MIN_WIDTH;

	// add up height of seek slider and heighest control on bottom
	float minHeight = 2 * BORDER_INSET;
	minHeight += fSeekSlider->Bounds().Height() + MIN_SPACE + MIN_SPACE / 2.0;
	minHeight += fBottomControlHeight;
	return BRect(0.0, 0.0, minWidth - 1.0, minHeight - 1.0);
}

// _LayoutControl
void
MediaControlView::_LayoutControl(BView* view, BRect frame,
                                 bool resizeWidth, bool resizeHeight) const
{
    if (!resizeHeight)
	    // center vertically
	    frame.top = (frame.top + frame.bottom) / 2.0 - view->Bounds().Height() / 2.0;
	if (!resizeWidth)
	    //center horizontally
		frame.left = (frame.left + frame.right) / 2.0 - view->Bounds().Width() / 2.0;
	view->MoveTo(frame.LeftTop());
	float width = resizeWidth ? frame.Width() : view->Bounds().Width();
	float height = resizeHeight ? frame.Height() : view->Bounds().Height();
    if (resizeWidth || resizeHeight)
        view->ResizeTo(width, height);
}



/*****************************************************************************
 * SeekSlider
 *****************************************************************************/
SeekSlider::SeekSlider( intf_thread_t * _p_intf,
                        BRect frame, const char* name, MediaControlView *owner )
	: BControl(frame, name, NULL, NULL, B_FOLLOW_NONE,
			   B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE),
	  p_intf(_p_intf),
	  fOwner(owner),
	  fTracking(false)
{
	BFont font(be_plain_font);
	font.SetSize(9.0);
	SetFont(&font);
}

SeekSlider::~SeekSlider()
{
}

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

/*****************************************************************************
 * VolumeSlider::Draw
 *****************************************************************************/
void
SeekSlider::Draw(BRect updateRect)
{
	BRect r(Bounds());
	float knobWidth2 = SEEK_SLIDER_KNOB_WIDTH / 2.0;
	float sliderStart = (r.left + knobWidth2);
	float sliderEnd = (r.right - knobWidth2);
	float knobPos = sliderStart
					+ floorf((sliderEnd - sliderStart - 1.0) * Value()
					/ SEEKSLIDER_RANGE);
	// 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 = kSeekGreen;
	rgb_color greenShadow = kSeekGreenShadow;
	rgb_color black = kBlack;
	rgb_color dotGrey = midShadow;
	rgb_color dotGreen = greenShadow;
	// draw frame
	_StrokeFrame(r, softShadow, softShadow, softLight, softLight);
	r.InsetBy(1.0, 1.0);
	_StrokeFrame(r, black, black, light, light);
	if (IsEnabled())
	{
		r.InsetBy(1.0, 1.0);
		// inner shadow
		_StrokeFrame(r, greenShadow, greenShadow, green, green);
		r.top++;
		r.left++;
		_StrokeFrame(r, greenShadow, greenShadow, green, green);
		// inside area
		r.InsetBy(1.0, 1.0);
		SetHighColor(green);
		FillRect(r);
		// dots
		int32 dotCount = (int32)(r.Width() / 6.0);
		BPoint dotPos;
		dotPos.y = r.top + 2.0;
		SetHighColor(dotGreen);
		for (int32 i = 0; i < dotCount; i++)
		{
			dotPos.x = sliderStart + i * 6.0 + 5.0;
			StrokeLine(dotPos, BPoint(dotPos.x, dotPos.y + 6.0));
		}
		// slider handle
		r.top -= 4.0;
		r.bottom += 3.0;
		r.left = knobPos - knobWidth2;
		r.right = knobPos + knobWidth2;
		// black outline
		float handleBottomSize = 2.0;
		float handleArrowSize = 6.0;
		BeginLineArray(10);
			// upper handle
			AddLine(BPoint(r.left, r.top + handleBottomSize),
					BPoint(r.left, r.top), black);
			AddLine(BPoint(r.left + 1.0, r.top),
					BPoint(r.right, r.top), black);
			AddLine(BPoint(r.right, r.top + 1.0),
					BPoint(r.right, r.top + handleBottomSize), black);
			AddLine(BPoint(r.right - 1.0, r.top + handleBottomSize + 1.0),
					BPoint(knobPos, r.top + handleArrowSize), black);
			AddLine(BPoint(knobPos - 1.0, r.top + handleArrowSize - 1.0),
					BPoint(r.left + 1.0, r.top + handleBottomSize + 1.0), black);
			// lower handle
			AddLine(BPoint(r.left, r.bottom),
					BPoint(r.left, r.bottom - handleBottomSize), black);
			AddLine(BPoint(r.left + 1.0, r.bottom - handleBottomSize - 1.0),
					BPoint(knobPos, r.bottom - handleArrowSize), black);
			AddLine(BPoint(knobPos + 1.0, r.bottom - handleArrowSize + 1.0),
					BPoint(r.right, r.bottom - handleBottomSize), black);
			AddLine(BPoint(r.right, r.bottom - handleBottomSize + 1.0),
					BPoint(r.right, r.bottom), black);
			AddLine(BPoint(r.right - 1.0, r.bottom),
					BPoint(r.left + 1.0, r.bottom), black);
		EndLineArray();
		// inner red light and shadow lines
		r.InsetBy(1.0, 1.0);
		handleBottomSize--;
		handleArrowSize -= 2.0;
		BeginLineArray(10);
			// upper handle
			AddLine(BPoint(r.left, r.top + handleBottomSize),
					BPoint(r.left, r.top), kSeekRedLight);
			AddLine(BPoint(r.left + 1.0, r.top),
					BPoint(r.right, r.top), kSeekRedLight);
			AddLine(BPoint(r.right, r.top + 1.0),
					BPoint(r.right, r.top + handleBottomSize), kSeekRedShadow);
			AddLine(BPoint(r.right - 1.0, r.top + handleBottomSize + 1.0),
					BPoint(knobPos, r.top + handleArrowSize), kSeekRedShadow);
			AddLine(BPoint(knobPos - 1.0, r.top + handleArrowSize - 1.0),
					BPoint(r.left + 1.0, r.top + handleBottomSize + 1.0), kSeekRedLight);
			// lower handle
			AddLine(BPoint(r.left, r.bottom),
					BPoint(r.left, r.bottom - handleBottomSize), kSeekRedLight);
			AddLine(BPoint(r.left + 1.0, r.bottom - handleBottomSize - 1.0),
					BPoint(knobPos, r.bottom - handleArrowSize), kSeekRedLight);
			AddLine(BPoint(knobPos + 1.0, r.bottom - handleArrowSize + 1.0),
					BPoint(r.right, r.bottom - handleBottomSize), kSeekRedShadow);
			AddLine(BPoint(r.right, r.bottom - handleBottomSize + 1.0),
					BPoint(r.right, r.bottom), kSeekRedShadow);
			AddLine(BPoint(r.right - 1.0, r.bottom),
					BPoint(r.left + 1.0, r.bottom), kSeekRedShadow);
		EndLineArray();
		// fill rest of handles with red
		SetHighColor(kSeekRed);
		r.InsetBy(1.0, 1.0);
		handleArrowSize -= 2.0;
		BPoint arrow[3];
		// upper handle arrow
		arrow[0].x = r.left;
		arrow[0].y = r.top;
		arrow[1].x = r.right;
		arrow[1].y = r.top;
		arrow[2].x = knobPos;
		arrow[2].y = r.top + handleArrowSize;
		FillPolygon(arrow, 3);
		// lower handle arrow
		arrow[0].x = r.left;
		arrow[0].y = r.bottom;
		arrow[1].x = r.right;
		arrow[1].y = r.bottom;
		arrow[2].x = knobPos;
		arrow[2].y = r.bottom - handleArrowSize;
		FillPolygon(arrow, 3);
	}
	else
	{
		r.InsetBy(1.0, 1.0);
		_StrokeFrame(r, darkShadow, darkShadow, darkShadow, darkShadow);
		r.InsetBy(1.0, 1.0);
		_StrokeFrame(r, darkShadow, darkShadow, darkShadow, darkShadow);
		r.InsetBy(1.0, 1.0);
		SetHighColor(darkShadow);
		SetLowColor(shadow);
		// stripes
		float width = floorf(StringWidth(DISABLED_SEEK_MESSAGE));
		float textPos = r.left + r.Width() / 2.0 - width / 2.0;
		pattern stripes = {{ 0xc7, 0x8f, 0x1f, 0x3e, 0x7c, 0xf8, 0xf1, 0xe3 }};
		BRect stripesRect(r);
		stripesRect.right = textPos - 5.0;
		FillRect(stripesRect, stripes);
		stripesRect.left = textPos + width + 3.0;
		stripesRect.right = r.right;
		FillRect(stripesRect, stripes);
		// info text
		r.left = textPos - 4.0;
		r.right = textPos + width + 2.0;
		FillRect(r);
		SetHighColor(shadow);
		SetLowColor(darkShadow);
		font_height fh;
		GetFontHeight(&fh);
		DrawString(DISABLED_SEEK_MESSAGE, BPoint(textPos, r.top + ceilf(fh.ascent) - 1.0));
	}
}

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

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

/*****************************************************************************
 * SeekSlider::MouseUp
 *****************************************************************************/
void
SeekSlider::MouseUp(BPoint where)
{
	if (fTracking)
	{
		fTracking = false;
		input_thread_t * p_input;
		p_input = (input_thread_t *)
            vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );

        if( p_input )
        {
		    var_SetFloat( p_input, "position",
		                  (float) Value() / SEEKSLIDER_RANGE );
		    vlc_object_release( p_input );
		}
	}
}

/*****************************************************************************
 * 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() )
	{
	    if( !fTracking )
	    {
		    SetValue( SEEKSLIDER_RANGE * position );
		}
		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 =  (int32)(((xPos - sliderStart) * SEEKSLIDER_RANGE)
				  / (sliderEnd - sliderStart - 1.0));
	if (value < 0)
		value = 0;
	if (value > SEEKSLIDER_RANGE)
		value = SEEKSLIDER_RANGE;
	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();
}

/*****************************************************************************
 * 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);