mediacontrolview.cpp

VLC Player Source Code

 * 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);
            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();
        memcpy(fKnobBits->Bits(), kVolumeSliderKnobBits, length);
        uint8* bits = (uint8*)fKnobBits->Bits();
        // black was used in the knob to represent transparency
        // use screen to get index for the "transarent" color used in the bitmap
        BScreen screen(B_MAIN_SCREEN_ID);
        uint8 blackIndex = screen.IndexForColor(kBlack);