/*
 * Copyright 2006, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 *              Ingo Weinhold <bonefish@cs.tu-berlin.de>
 */

#include "PopupSlider.h"

#include <math.h>
#include <stdio.h>

#include <Message.h>

#include <MDividable.h>
#include <MWindow.h>

#include "SliderView.h"

// constructor
PopupSlider::PopupSlider(const char* name, const char* label,
                                                 BMessage* model, BHandler* target,
                                                 int32 min, int32 max, int32 value,
                                                 const char* formatString)
        : PopupControl(name, fSlider = new SliderView(this, min, max, value,
                                                                                                  formatString)),
          MDividable(),
          fModel(model),
          fPressModel(NULL),
          fReleaseModel(NULL),
          fTarget(target),
          fLabel(label),
          fSliderButtonRect(0.0, 0.0, -1.0, -1.0),
          fEnabled(true),
          fTracking(false)
{
        SetViewColor(B_TRANSPARENT_32_BIT);
}

// destructor
PopupSlider::~PopupSlider()
{
        delete fModel;
        if (BWindow* window = fSlider->Window()) {
                window->Lock();
                window->RemoveChild(fSlider);
                window->Unlock();
        }
        delete fSlider;
}

// layoutprefs
minimax
PopupSlider::layoutprefs()
{
        BFont font;
        GetFont(&font);
        font_height fh;
        font.GetHeight(&fh);
        float labelHeight = 2.0 + ceilf(fh.ascent + fh.descent) + 2.0;
        float sliderWidth, sliderHeight;
        SliderView::GetSliderButtonDimensions(Max(), FormatString(), &font,
                                                                                  sliderWidth, sliderHeight);

        float height = labelHeight > sliderHeight + 2.0 ?
                                                labelHeight : sliderHeight + 2.0;

        float minLabelWidth = LabelWidth();
        if (rolemodel)
                labelwidth = rolemodel->LabelWidth();
        labelwidth = minLabelWidth > labelwidth ? minLabelWidth : labelwidth;

        fSliderButtonRect.left = labelwidth;
        fSliderButtonRect.right = fSliderButtonRect.left + sliderWidth + 2.0;
        fSliderButtonRect.top = floorf(height / 2.0 - (sliderHeight + 2.0) / 2.0);
        fSliderButtonRect.bottom = fSliderButtonRect.top + sliderHeight + 2.0;

        fSliderButtonRect.OffsetTo(Bounds().right - fSliderButtonRect.Width(),
                                                           fSliderButtonRect.top);

        mpm.mini.x = labelwidth + fSliderButtonRect.Width() + 1.0;
        mpm.maxi.x = 10000.0;
        mpm.mini.y = mpm.maxi.y = height + 1.0;

        mpm.weight = 1.0;

        return mpm;
}

// layout
BRect
PopupSlider::layout(BRect frame)
{
        MoveTo(frame.LeftTop());
        ResizeTo(frame.Width(), frame.Height());

        fSliderButtonRect.OffsetTo(Bounds().right - fSliderButtonRect.Width(),
                                                           fSliderButtonRect.top);
        return Frame();
}

// MessageReceived
void
PopupSlider::MessageReceived(BMessage* message)
{
        switch (message->what) {
                default:
                        PopupControl::MessageReceived(message);
                        break;
        }
}

// AttachedToWindow
void
PopupSlider::AttachedToWindow()
{
        fSliderButtonRect.OffsetTo(Bounds().right - fSliderButtonRect.Width(),
                                                           fSliderButtonRect.top);
        PopupControl::AttachedToWindow();
}

// Draw
void
PopupSlider::Draw(BRect updateRect)
{
        bool enabled = IsEnabled();
        rgb_color background = ui_color(B_PANEL_BACKGROUND_COLOR);
        rgb_color black;
        if (enabled) {
                black = tint_color(background, B_DARKEN_MAX_TINT);
        } else {
                black = tint_color(background, B_DISABLED_LABEL_TINT);
        }
        // draw label
        BRect r(Bounds());
        r.right = fSliderButtonRect.left - 1.0;
        font_height fh;
        GetFontHeight(&fh);
        BPoint textPoint(0.0, (r.top + r.bottom) / 2.0 + fh.ascent / 2.0);
        SetLowColor(background);
        SetHighColor(black);
        FillRect(r, B_SOLID_LOW);
        DrawString(fLabel.String(), textPoint);
        // draw slider button
        DrawSlider(fSliderButtonRect, enabled);
}

// MouseDown
void
PopupSlider::MouseDown(BPoint where)
{
        if (fEnabled && fSliderButtonRect.Contains(where) &&
                !fSlider->LockLooper()) {
                
                SetPopupLocation(BPoint(fSliderButtonRect.left + 1.0
                                                                - fSlider->ButtonOffset(),
                                                                -5.0));
                where.x -= fSliderButtonRect.left + 1.0;
                fSlider->SetDragOffset(where.x);
                // just to be on the safe side (avoid a dead lock)
                fTracking = true;
                ShowPopup(&where);
//              fSlider->SetDragOffset(where.x);
        }
}

// PopupShown
void
PopupSlider::PopupShown()
{
        TriggerValueChanged(fPressModel);
        fTracking = true;
}

// PopupHidden
void
PopupSlider::PopupHidden(bool canceled)
{
        TriggerValueChanged(fReleaseModel);
        fTracking = false;
}

// SetValue
void            
PopupSlider::SetValue(int32 value)
{
        if (!fTracking) {
/*              if (fSlider->LockLooper()) {
                        fSlider->SetValue(value);
                        fSlider->UnlockLooper();
                } else*/
                if (value != Value()) {
                        fSlider->SetValue(value);
                        if (LockLooperWithTimeout(0) >= B_OK) {
                                Invalidate();
                                UnlockLooper();
                        }
                }
        } else
                ValueChanged(value);
}

// Value
int32   
PopupSlider::Value() const
{
        int32 value = 0;
/*      if (fSlider->LockLooper()) {
                value = fSlider->Value();
                fSlider->UnlockLooper();
        } else*/
                value = fSlider->Value();
        return value;
}

// SetEnabled
void
PopupSlider::SetEnabled(bool enable)
{
        if (enable != fEnabled) {
                fEnabled = enable;
                if (LockLooper()) {
                        Invalidate();
                        UnlockLooper();
                }
        }
}

// SetEnabled
bool
PopupSlider::IsEnabled() const
{
        return fEnabled;
}

// TriggerValueChanged
void
PopupSlider::TriggerValueChanged(const BMessage* message) const
{
        if (message && fTarget) {
                BMessage msg(*message);
                msg.AddInt64("be:when", system_time());
                msg.AddInt32("be:value", Value());
                msg.AddPointer("be:source", (void*)this);
                if (BLooper* looper = fTarget->Looper())
                        looper->PostMessage(&msg, fTarget);
        }
}

// IsTracking
bool
PopupSlider::IsTracking() const
{
        return fTracking;
}

// ValueChanged
void
PopupSlider::ValueChanged(int32 newValue)
{
        TriggerValueChanged(fModel);
}

// DrawSlider
void
PopupSlider::DrawSlider(BRect frame, bool enabled)
{
        rgb_color background = ui_color(B_PANEL_BACKGROUND_COLOR);
        rgb_color lightShadow;
        rgb_color darkShadow;
        if (enabled) {
                lightShadow = tint_color(background, B_DARKEN_2_TINT);
                darkShadow = tint_color(background, B_DARKEN_4_TINT);
        } else {
                lightShadow = tint_color(background, B_DARKEN_1_TINT);
                darkShadow = tint_color(background, B_DARKEN_2_TINT);
        }

        BeginLineArray(4);
                AddLine(BPoint(frame.left, frame.bottom),
                                BPoint(frame.left, frame.top), lightShadow);
                AddLine(BPoint(frame.left + 1.0, frame.top),
                                BPoint(frame.right, frame.top), lightShadow);
                AddLine(BPoint(frame.right, frame.top + 1.0),
                                BPoint(frame.right, frame.bottom), darkShadow);
                AddLine(BPoint(frame.right - 1.0, frame.bottom),
                                BPoint(frame.left + 1.0, frame.bottom), darkShadow);
        EndLineArray();

        frame.InsetBy(1.0, 1.0);
        SliderView::DrawSliderButton(this, frame, Value(), FormatString(), enabled);
}

// Scale
float
PopupSlider::Scale(float ratio) const
{
        return ratio;
}

// DeScale
float
PopupSlider::DeScale(float ratio) const
{
        return ratio;
}

// SetMessage
void
PopupSlider::SetMessage(BMessage* message)
{
        delete fModel;
        fModel = message;
}

// SetPressedMessage
void
PopupSlider::SetPressedMessage(BMessage* message)
{
        delete fPressModel;
        fPressModel = message;
}

// SetReleasedMessage
void
PopupSlider::SetReleasedMessage(BMessage* message)
{
        delete fReleaseModel;
        fReleaseModel = message;
}

// SetMin
void            
PopupSlider::SetMin(int32 min)
{
/*      if (fSlider->LockLooper()) {
                fSlider->SetMin(min);
                fSlider->UnlockLooper();
        } else*/
                fSlider->SetMin(min);
}

// Min
int32           
PopupSlider::Min() const
{
        int32 value = 0;
/*      if (fSlider->LockLooper()) {
                value = fSlider->Min();
                fSlider->UnlockLooper();
        } else*/
                value = fSlider->Min();
        return value;
}

// SetMax
void
PopupSlider::SetMax(int32 max)
{
/*      if (fSlider->LockLooper()) {
                fSlider->SetMax(max);
                fSlider->UnlockLooper();
        } else*/
                fSlider->SetMax(max);
}

// Max
int32
PopupSlider::Max() const
{
        int32 value = 0;
/*      if (fSlider->LockLooper()) {
                value = fSlider->Max();
                fSlider->UnlockLooper();
        } else*/
                value = fSlider->Max();
        return value;
}

// SetLabel
void    
PopupSlider::SetLabel(const char* label)
{
        fLabel.SetTo(label);
        Invalidate();
}

// Label
const char*     
PopupSlider::Label() const
{
        return fLabel.String();
}

// LabelWidth
float
PopupSlider::LabelWidth()
{
        return _MinLabelWidth();
}

// StringForValue
const char*
PopupSlider::StringForValue(int32 value)
{
        return NULL;
}

// MaxValueStringWidth
float
PopupSlider::MaxValueStringWidth()
{
        return 0.0;
}

// SetFormatString
void    
PopupSlider::SetFormatString(const char* formatString)
{
/*      if (fSlider->LockLooper()) {
                fSlider->SetFormatString(formatString);
                fSlider->UnlockLooper();
        } else*/
                fSlider->SetFormatString(formatString);
}

// FormatString
const char*     
PopupSlider::FormatString() const
{
        return fSlider->FormatString();
}

// _MinLabelWidth
float
PopupSlider::_MinLabelWidth() const
{
        return ceilf(StringWidth(fLabel.String())) + 5.0;
}

/*
// StringForValue
const char*
PercentSlider::StringForValue(int32 value)
{
        BString string;
        string << (value * 100) / Max() << "%";
        return 
}
*/