/*
 * Copyright 2005, Jérôme Duval. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Inspired by SoundCapture from Be newsletter (Media Kit Basics: Consumers 
 * and Producers)
 */
 
#include <stdio.h>
#include <string.h>
#include <Screen.h>

#include "TrackSlider.h"
#include "icon_button.h"

TrackSlider::TrackSlider(BRect rect, const char *title, BMessage *msg, 
        uint32 resizeFlags)
        : 
        BControl(rect, "slider", NULL, msg, resizeFlags, B_WILL_DRAW 
                | B_FRAME_EVENTS),
        fLeftTime(0),
        fRightTime(1000000),
        fMainTime(0),
        fTotalTime(1000000),
        fLeftTracking(false),
        fRightTracking(false), 
        fMainTracking(false),
        fBitmap(NULL),
        fBitmapView(NULL)
{
        fFont.SetSize(8.0);
        fFont.SetFlags(B_DISABLE_ANTIALIASING);
        
        int32 numFamilies = count_font_families(); 
        for (int32 i = 0; i < numFamilies; i++ ) { 
                font_family family; 
                uint32 flags; 
                if ((get_font_family(i, &family, &flags) == B_OK)
                        && (strcmp(family, "Baskerville") == 0)) {
                        fFont.SetFamilyAndFace(family, B_REGULAR_FACE);
                        break;
                }
        }
        
}


TrackSlider::~TrackSlider()
{
        delete fBitmap;
}


void
TrackSlider::AttachedToWindow()
{
        BControl::AttachedToWindow();
        SetViewColor(B_TRANSPARENT_COLOR);
        _InitBitmap();
        _RenderBitmap();
}


void
TrackSlider::_InitBitmap()
{
        if (fBitmap != NULL) {
                if (fBitmapView != NULL) {
                        fBitmap->RemoveChild(fBitmapView);
                        delete fBitmapView;
                }
                delete fBitmap;
        }

        BRect rect = Bounds();
        
        fBitmap = new BBitmap(rect, BScreen().ColorSpace(), true);
        
        fBitmapView = new SliderOffscreenView(rect.OffsetToSelf(B_ORIGIN), "bitmapView");
        fBitmap->AddChild(fBitmapView);
        
        fBitmapView->fRight = Bounds().right - kLeftRightTrackSliderWidth;
        if (fTotalTime == 0) {
                fBitmapView->fLeftX = 14;
                fBitmapView->fRightX = fBitmapView->fRight;
                fBitmapView->fPositionX = 15;
        } else {
                fBitmapView->fLeftX = 14 + (fBitmapView->fRight - 15) 
                        * ((double)fLeftTime / fTotalTime);
                fBitmapView->fRightX = 15 + (fBitmapView->fRight - 16) 
                        * ((double)fRightTime / fTotalTime);
                fBitmapView->fPositionX = 15 + (fBitmapView->fRight - 14) 
                        * ((double)fMainTime / fTotalTime);
        }
}

#define SLIDER_BASE 10

void
TrackSlider::_RenderBitmap()
{
        /* rendering */
        if (fBitmap->Lock()) {
                fBitmapView->DrawX();
                fBitmap->Unlock();
        }
}


void
TrackSlider::Draw(BRect updateRect)
{       
        DrawBitmapAsync(fBitmap, BPoint(0,0));
                
        _DrawCounter(fMainTime, fBitmapView->fPositionX, fMainTracking);
        if (fLeftTracking)
                _DrawCounter(fLeftTime, fBitmapView->fLeftX, fLeftTracking);
        else if (fRightTracking)
                _DrawCounter(fRightTime, fBitmapView->fRightX, fRightTracking);
        
        _DrawMarker(fBitmapView->fPositionX);   
        
        Sync();
}


void
TrackSlider::_DrawCounter(bigtime_t timestamp, float position, bool isTracking)
{
        // timecounter
        
        rgb_color gray = {128,128,128};
        rgb_color blue = {0,0,140};
        rgb_color blue2 = {146,146,214};
        rgb_color white = {255,255,255};
        
        char string[12];
        _TimeToString(timestamp, string);
        int32 halfwidth = ((int32)fFont.StringWidth(string)) / 2;
        
        float counterX = position;
        if (counterX < 39)
                counterX = 39;
        if (counterX > fBitmapView->fRight - 23)
                counterX = fBitmapView->fRight - 23;
        
        BeginLineArray(4);
        if (!isTracking) {
                AddLine(BPoint(counterX-halfwidth-3,SLIDER_BASE+1), 
                        BPoint(counterX+halfwidth+3,SLIDER_BASE+1), gray);
                AddLine(BPoint(counterX+halfwidth+4,SLIDER_BASE+1), 
                        BPoint(counterX+halfwidth+4,SLIDER_BASE-8), gray);
                AddLine(BPoint(counterX-halfwidth-4,SLIDER_BASE+1), 
                        BPoint(counterX-halfwidth-4,SLIDER_BASE-9), white);
                AddLine(BPoint(counterX-halfwidth-3,SLIDER_BASE-9), 
                        BPoint(counterX+halfwidth+4,SLIDER_BASE-9), white);
                SetHighColor(216,216,216);
        } else {
                AddLine(BPoint(counterX-halfwidth-3,SLIDER_BASE+1), 
                        BPoint(counterX+halfwidth+3,SLIDER_BASE+1), blue);
                AddLine(BPoint(counterX+halfwidth+4,SLIDER_BASE+1), 
                        BPoint(counterX+halfwidth+4,SLIDER_BASE-9), blue2);
                AddLine(BPoint(counterX-halfwidth-4,SLIDER_BASE+1), 
                        BPoint(counterX-halfwidth-4,SLIDER_BASE-9), blue2);
                AddLine(BPoint(counterX-halfwidth-3,SLIDER_BASE-9), 
                        BPoint(counterX+halfwidth+3,SLIDER_BASE-9), blue2);
                SetHighColor(48,48,241);
        }
        EndLineArray();
        FillRect(BRect(counterX-halfwidth-3,SLIDER_BASE-8,counterX+halfwidth+3,
                SLIDER_BASE));

#ifdef __HAIKU__
        SetDrawingMode(B_OP_OVER);
#else
        SetDrawingMode(B_OP_COPY);
#endif
        if (isTracking)
                SetHighColor(255,255,255);
        else
                SetHighColor(0,0,0);
        SetLowColor(ViewColor());
        
        SetFont(&fFont);
        DrawString(string, BPoint(counterX-halfwidth, SLIDER_BASE-1));

}


void
TrackSlider::_DrawMarker(float position)
{
        rgb_color black = {0,0,0};
        rgb_color rose = {255,152,152};
        rgb_color red = {255,0,0};
        rgb_color bordeau = {178,0,0};
        rgb_color white = {255,255,255};
                
        BeginLineArray(30);
        AddLine(BPoint(position,SLIDER_BASE+7), BPoint(position-4,SLIDER_BASE+3), 
                black);
        AddLine(BPoint(position-4,SLIDER_BASE+3), BPoint(position-4,SLIDER_BASE+1),
                black);
        AddLine(BPoint(position-4,SLIDER_BASE+1), BPoint(position+4,SLIDER_BASE+1),
                black);
        AddLine(BPoint(position+4,SLIDER_BASE+1), BPoint(position+4,SLIDER_BASE+3),
                black);
        AddLine(BPoint(position+4,SLIDER_BASE+3), BPoint(position,SLIDER_BASE+7),
                black);
        
        
        AddLine(BPoint(position-3,SLIDER_BASE+2), BPoint(position+3,SLIDER_BASE+2),
                rose);
        AddLine(BPoint(position-3,SLIDER_BASE+3), BPoint(position-1,SLIDER_BASE+5),
                rose);
        
        AddLine(BPoint(position-2,SLIDER_BASE+3), BPoint(position+2,SLIDER_BASE+3),
                red);
        AddLine(BPoint(position-1,SLIDER_BASE+4), BPoint(position+1,SLIDER_BASE+4),
                red);
        AddLine(BPoint(position,SLIDER_BASE+5), BPoint(position,SLIDER_BASE+5),
                red);
        
        AddLine(BPoint(position,SLIDER_BASE+6), BPoint(position+3,SLIDER_BASE+3),
                bordeau);
        
        AddLine(BPoint(position,SLIDER_BASE+12), BPoint(position-4,SLIDER_BASE+16),
                black);
        AddLine(BPoint(position-4,SLIDER_BASE+16), BPoint(position-4,
                SLIDER_BASE+17), black);
        AddLine(BPoint(position-4,SLIDER_BASE+17), BPoint(position+4,
                SLIDER_BASE+17), black);
        AddLine(BPoint(position+4,SLIDER_BASE+17), BPoint(position+4,
                SLIDER_BASE+16), black);
        AddLine(BPoint(position+4,SLIDER_BASE+16), BPoint(position,SLIDER_BASE+12),
                black);
        AddLine(BPoint(position-4,SLIDER_BASE+18), BPoint(position+4,
                SLIDER_BASE+18), white);
        
        AddLine(BPoint(position-3,SLIDER_BASE+16), BPoint(position,SLIDER_BASE+13),
                rose);
        
        AddLine(BPoint(position-2,SLIDER_BASE+16), BPoint(position+2,
                SLIDER_BASE+16), red);
        AddLine(BPoint(position-1,SLIDER_BASE+15), BPoint(position+1,
                SLIDER_BASE+15), red);
        AddLine(BPoint(position,SLIDER_BASE+14), BPoint(position,
                SLIDER_BASE+14), red);
        
        AddLine(BPoint(position+1,SLIDER_BASE+14), BPoint(position+3,
                SLIDER_BASE+16), bordeau);
        
        EndLineArray();
}


void 
TrackSlider::MouseMoved(BPoint point, uint32 transit, const BMessage *message)
{
        if (!IsTracking())
                return;
                
        uint32 mouseButtons;
        BPoint where;
        GetMouse(&where, &mouseButtons, true);
        
        // button not pressed, exit
        if (! (mouseButtons & B_PRIMARY_MOUSE_BUTTON)) {
                Invoke();
                SetTracking(false);
        }
        
        _UpdatePosition(point);
}


void
TrackSlider::MouseDown(BPoint point)
{
        if (!Bounds().InsetBySelf(2,2).Contains(point))
                return;

        _UpdatePosition(point);
        SetTracking(true);
        SetMouseEventMask(B_POINTER_EVENTS, B_NO_POINTER_HISTORY 
                | B_LOCK_WINDOW_FOCUS);
}


void
TrackSlider::MouseUp(BPoint point)
{
        if (!IsTracking())
                return;
        if (Bounds().InsetBySelf(2,2).Contains(point)) {
                _UpdatePosition(point);
        }
        
        fLeftTracking = fRightTracking = fMainTracking = false;
        
        Invoke();
        SetTracking(false);
        Draw(Bounds());
        Flush();
}


void
TrackSlider::_UpdatePosition(BPoint point)
{
        BRect leftRect(fBitmapView->fLeftX-9, SLIDER_BASE+3, fBitmapView->fLeftX, 
                SLIDER_BASE+16);
        BRect rightRect(fBitmapView->fRightX, SLIDER_BASE+3, 
                fBitmapView->fRightX+9, SLIDER_BASE+16);
        
        if (!(fRightTracking || fMainTracking) && (fLeftTracking 
                || ((point.x < fBitmapView->fPositionX-4) && leftRect.Contains(point)))) {
                if (!IsTracking())
                        fBitmapView->fLastX = point.x - fBitmapView->fLeftX;
                fBitmapView->fLeftX = MIN(MAX(point.x - fBitmapView->fLastX, 15), 
                        fBitmapView->fRight);
                fLeftTime = (bigtime_t)(MAX(MIN((fBitmapView->fLeftX - 15) 
                        / (fBitmapView->fRight - 14),1), 0) * fTotalTime);
                fLeftTracking = true;
                
                BMessage msg = *Message();
                msg.AddInt64("left", fLeftTime);
                
                if (fBitmapView->fPositionX < fBitmapView->fLeftX) {
                        fBitmapView->fPositionX = fBitmapView->fLeftX + 1;
                        fMainTime = fLeftTime;
                        msg.AddInt64("main", fMainTime);
                        if (fBitmapView->fRightX < fBitmapView->fPositionX) {
                                fBitmapView->fRightX = fBitmapView->fPositionX;
                                fRightTime = fMainTime;
                                msg.AddInt64("right", fRightTime);
                        }
                }
                
                Invoke(&msg);
                _RenderBitmap();
                
                //printf("fLeftPos : %lld\n", fLeftTime);
        } else if (!fMainTracking && (fRightTracking 
                || ((point.x > fBitmapView->fPositionX+4) 
                && rightRect.Contains(point)))) {
                if (!IsTracking())
                        fBitmapView->fLastX = point.x - fBitmapView->fRightX;
                fBitmapView->fRightX = MIN(MAX(point.x - fBitmapView->fLastX, 15), 
                        fBitmapView->fRight);
                fRightTime = (bigtime_t)(MAX(MIN((fBitmapView->fRightX - 15) 
                        / (fBitmapView->fRight - 14),1), 0) * fTotalTime);
                fRightTracking = true;
                
                BMessage msg = *Message();
                msg.AddInt64("right", fRightTime);
                
                if (fBitmapView->fPositionX > fBitmapView->fRightX) {
                        fBitmapView->fPositionX = fBitmapView->fRightX;
                        fMainTime = fRightTime;
                        msg.AddInt64("main", fMainTime);
                        if (fBitmapView->fLeftX > fBitmapView->fPositionX) {
                                fBitmapView->fLeftX = fBitmapView->fPositionX - 1;
                                fLeftTime = fMainTime;
                                msg.AddInt64("left", fLeftTime);
                        }
                }
                
                Invoke(&msg);
                _RenderBitmap();
                
                //printf("fRightPos : %lld\n", fRightTime);
        } else {
                fBitmapView->fPositionX = MIN(MAX(point.x, 15), fBitmapView->fRight);
                fMainTime = (bigtime_t)(MAX(MIN((fBitmapView->fPositionX - 15) 
                        / (fBitmapView->fRight - 14),1), 0) * fTotalTime);
                fMainTracking = true;
                
                BMessage msg = *Message();
                msg.AddInt64("main", fMainTime);
                
                if (fBitmapView->fRightX < fBitmapView->fPositionX) {
                        fBitmapView->fRightX = fBitmapView->fPositionX;
                        fRightTime = fMainTime;
                        msg.AddInt64("right", fRightTime);
                        _RenderBitmap();
                } else if (fBitmapView->fLeftX > fBitmapView->fPositionX) {
                        fBitmapView->fLeftX = fBitmapView->fPositionX - 1;
                        fLeftTime = fMainTime;
                        msg.AddInt64("left", fLeftTime);
                        _RenderBitmap();
                }
                
                Invoke(&msg);
                //printf("fPosition : %lld\n", fMainTime);
        }
        Draw(Bounds());
        Flush();
}


void 
TrackSlider::_TimeToString(bigtime_t timestamp, char *string)
{
        uint32 hours = timestamp / 3600000000LL;
        timestamp -= hours * 3600000000LL;
        uint32 minutes = timestamp / 60000000LL;
        timestamp -= minutes * 60000000LL;
        uint32 seconds = timestamp / 1000000LL;
        timestamp -= seconds * 1000000LL;
        uint32 centiseconds = timestamp / 10000LL;
        sprintf(string, "%02" B_PRId32 ":%02" B_PRId32 ":%02" B_PRId32 ":%02"
                B_PRId32, hours, minutes, seconds, centiseconds);
}


void 
TrackSlider::SetMainTime(bigtime_t timestamp, bool reset)
{
        fMainTime = timestamp;
        fBitmapView->fPositionX = 15 + (fBitmapView->fRight - 14) 
                * ((double)fMainTime / fTotalTime);
        if (reset) {
                fRightTime = fTotalTime;
                fLeftTime = 0;
                fBitmapView->fLeftX = 14 + (fBitmapView->fRight - 15) 
                        * ((double)fLeftTime / fTotalTime);
                fBitmapView->fRightX = 15 + (fBitmapView->fRight - 16) 
                        * ((double)fRightTime / fTotalTime);
                _RenderBitmap();
        }
        Invalidate();
}

void 
TrackSlider::SetTotalTime(bigtime_t timestamp, bool reset)
{
        fTotalTime = timestamp;
        if (reset) {
                fMainTime = 0;
                fRightTime = fTotalTime;
                fLeftTime = 0;
        }
        fBitmapView->fPositionX = 15 + (fBitmapView->fRight - 14) 
                * ((double)fMainTime / fTotalTime);
        fBitmapView->fLeftX = 14 + (fBitmapView->fRight - 15) 
                * ((double)fLeftTime / fTotalTime);
        fBitmapView->fRightX = 15 + (fBitmapView->fRight - 16) 
                * ((double)fRightTime / fTotalTime);
        _RenderBitmap();
        Invalidate();
}


void
TrackSlider::ResetMainTime()
{
        fMainTime = fLeftTime;
        fBitmapView->fPositionX = 15 + (fBitmapView->fRight - 14) 
                * ((double)fMainTime / fTotalTime);
        Invalidate();
}


void 
TrackSlider::FrameResized(float width, float height)
{
        fBitmapView->fRight = Bounds().right - kLeftRightTrackSliderWidth;
        fBitmapView->fPositionX = 15 + (fBitmapView->fRight - 14) 
                * ((double)fMainTime / fTotalTime);
        _InitBitmap();
        fBitmapView->fLeftX = 14 + (fBitmapView->fRight - 15) 
                * ((double)fLeftTime / fTotalTime);
        fBitmapView->fRightX = 15 + (fBitmapView->fRight - 16) 
                * ((double)fRightTime / fTotalTime);
        _RenderBitmap();
        Invalidate();
}


SliderOffscreenView::SliderOffscreenView(BRect frame, const char *name)
        : BView(frame, name, B_FOLLOW_LEFT | B_FOLLOW_TOP, B_WILL_DRAW),
        leftBitmap(BRect(BPoint(0,0), kLeftRightTrackSliderSize), B_CMAP8),
        rightBitmap(BRect(BPoint(0,0), kLeftRightTrackSliderSize), B_CMAP8),
        leftThumbBitmap(BRect(0, 0, kLeftRightThumbWidth - 1, 
                kLeftRightThumbHeight - 1), B_CMAP8),
        rightThumbBitmap(BRect(0, 0, kLeftRightThumbWidth - 1, 
                kLeftRightThumbHeight - 1), B_CMAP8)
{
        leftBitmap.SetBits(kLeftTrackSliderBits, 
                kLeftRightTrackSliderWidth * kLeftRightTrackSliderHeight, 0, B_CMAP8);
        rightBitmap.SetBits(kRightTrackSliderBits, 
                kLeftRightTrackSliderWidth * kLeftRightTrackSliderHeight, 0, B_CMAP8);
        leftThumbBitmap.SetBits(kLeftThumbBits, 
                kLeftRightThumbWidth * kLeftRightThumbHeight, 0, B_CMAP8);
        rightThumbBitmap.SetBits(kRightThumbBits, 
                kLeftRightThumbWidth * kLeftRightThumbHeight, 0, B_CMAP8);
}


SliderOffscreenView::~SliderOffscreenView()
{

}


void
SliderOffscreenView::DrawX()
{
        SetHighColor(ui_color(B_PANEL_BACKGROUND_COLOR));
        FillRect(Bounds());
        
        SetHighColor(189, 186, 189);
        StrokeLine(BPoint(11, SLIDER_BASE + 1), BPoint(fRight, SLIDER_BASE + 1));
        SetHighColor(0, 0, 0);
        StrokeLine(BPoint(11, SLIDER_BASE + 2), BPoint(fRight, SLIDER_BASE + 2));
        SetHighColor(255, 255, 255);
        StrokeLine(BPoint(11, SLIDER_BASE + 17), BPoint(fRight, SLIDER_BASE + 17));
        SetHighColor(231, 227, 231);
        StrokeLine(BPoint(11, SLIDER_BASE + 18), BPoint(fRight, SLIDER_BASE + 18));
        
        SetDrawingMode(B_OP_OVER);
        SetLowColor(HighColor());

        BPoint leftPoint(5, SLIDER_BASE + 1);
        DrawBitmapAsync(&leftBitmap, BRect(BPoint(0, 0), 
                kLeftRightTrackSliderSize - BPoint(5, 0)),
                BRect(leftPoint, leftPoint + kLeftRightTrackSliderSize - BPoint(5, 0)));
        BPoint rightPoint(fRight + 1, SLIDER_BASE + 1);
        DrawBitmapAsync(&rightBitmap, BRect(BPoint(5, 0), kLeftRightTrackSliderSize), 
                BRect(rightPoint, rightPoint + kLeftRightTrackSliderSize-BPoint(5, 0)));
                
        SetHighColor(153, 153, 153);
        FillRect(BRect(11, SLIDER_BASE + 3, fLeftX - 9, SLIDER_BASE + 16));
        FillRect(BRect(fRightX + 9, SLIDER_BASE + 3, fRight, SLIDER_BASE + 16));
        if (fLeftX > 19) {
                StrokeLine(BPoint(fLeftX - 9, SLIDER_BASE + 3), BPoint(fLeftX - 6, 
                        SLIDER_BASE + 3));
                StrokeLine(BPoint(fLeftX - 9, SLIDER_BASE + 4), BPoint(fLeftX - 7, 
                        SLIDER_BASE + 4));
                StrokeLine(BPoint(fLeftX - 9, SLIDER_BASE + 5), BPoint(fLeftX - 8, 
                        SLIDER_BASE + 5));
                StrokeLine(BPoint(fLeftX - 9, SLIDER_BASE + 16), BPoint(fLeftX - 6, 
                        SLIDER_BASE + 16));
                StrokeLine(BPoint(fLeftX - 9, SLIDER_BASE + 15), BPoint(fLeftX - 7, 
                        SLIDER_BASE + 15));
                StrokeLine(BPoint(fLeftX - 9, SLIDER_BASE + 14), BPoint(fLeftX - 8, 
                        SLIDER_BASE + 14));
        }
        if (fRightX < fRight - 5) {
                StrokeLine(BPoint(fRightX + 5, SLIDER_BASE + 3), BPoint(fRightX + 8, 
                        SLIDER_BASE + 3));
                StrokeLine(BPoint(fRightX + 7, SLIDER_BASE + 4), BPoint(fRightX + 8, 
                        SLIDER_BASE + 4));
                StrokeLine(BPoint(fRightX + 8, SLIDER_BASE + 5), BPoint(fRightX + 8, 
                        SLIDER_BASE + 6));
                StrokeLine(BPoint(fRightX + 8, SLIDER_BASE + 13), BPoint(fRightX + 8, 
                        SLIDER_BASE + 14));
                StrokeLine(BPoint(fRightX + 5, SLIDER_BASE + 16), BPoint(fRightX + 8, 
                        SLIDER_BASE + 16));
                StrokeLine(BPoint(fRightX + 7, SLIDER_BASE + 15), BPoint(fRightX + 8, 
                        SLIDER_BASE + 15));
        }
        SetHighColor(144, 186, 136);
        FillRect(BRect(fLeftX + 1, SLIDER_BASE + 3, fRightX, SLIDER_BASE + 4));
        FillRect(BRect(fLeftX + 1, SLIDER_BASE + 5, fLeftX + 2, SLIDER_BASE + 16));
        SetHighColor(171, 221, 161);
        FillRect(BRect(fLeftX + 3, SLIDER_BASE + 5, fRightX, SLIDER_BASE + 16));
        
        int i = 17;
        int j = 18;
        SetHighColor(128, 128, 128);
        for (; i < fLeftX - 9; i += 6) {
                StrokeLine(BPoint(i, SLIDER_BASE + 7), BPoint(i, SLIDER_BASE + 13));
        }
        SetHighColor(179, 179, 179);
        for (; j < fLeftX - 9; j += 6) {
                StrokeLine(BPoint(j, SLIDER_BASE + 7), BPoint(j, SLIDER_BASE + 13));
        }
        
        while (i <= fLeftX)
                i += 6;
        while (j <= fLeftX)
                j += 6;
        
        SetHighColor(144, 186, 136);
        for (; i <= fRightX; i += 6) {
                StrokeLine(BPoint(i, SLIDER_BASE + 7), BPoint(i, SLIDER_BASE + 13));
        }               
        SetHighColor(189, 244, 178);
        for (; j <= fRightX; j += 6) {
                StrokeLine(BPoint(j, SLIDER_BASE + 7), BPoint(j, SLIDER_BASE + 13));
        }
        
        while (i <= fRightX + 9)
                i += 6;
        while (j <= fRightX + 9)
                j += 6;
        
        SetHighColor(128, 128, 128);
        for (; i <= fRight + 1; i += 6) {
                StrokeLine(BPoint(i, SLIDER_BASE + 7), BPoint(i, SLIDER_BASE + 13));
        }
        SetHighColor(179, 179, 179);
        for (; j <= fRight + 1; j += 6) {
                StrokeLine(BPoint(j, SLIDER_BASE + 7), BPoint(j, SLIDER_BASE + 13));
        }
        
        SetLowColor(HighColor());
        
        BPoint leftThumbPoint(fLeftX - 8, SLIDER_BASE + 3);
        DrawBitmapAsync(&leftThumbBitmap, BRect(BPoint(0, 0), 
                kLeftRightThumbSize - BPoint(7, 0)),
                BRect(leftThumbPoint, leftThumbPoint 
                        + kLeftRightThumbSize - BPoint(7, 0)));
        
        BPoint rightThumbPoint(fRightX, SLIDER_BASE + 3);
        DrawBitmapAsync(&rightThumbBitmap, BRect(BPoint(6, 0), 
                kLeftRightThumbSize), 
                BRect(rightThumbPoint, rightThumbPoint 
                        + kLeftRightThumbSize-BPoint(6, 0)));
        
        Sync();
}