/*
 * Copyright 2012, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Marc Flerackers (mflerackers@androme.be)
 *              Stefano Ceccherini (stefano.ceccherini@gmail.com)
 *              John Scipione (jscipione@gmail.com)
 */


#include "InlineScrollView.h"

#include <ControlLook.h>
#include <Debug.h>
#include <InterfaceDefs.h>
#include <Menu.h>
#include <Point.h>
#include <Screen.h>
#include <Window.h>


const int kDefaultScrollStep = 19;
const int kScrollerDimension = 12;


class ScrollArrow : public BView {
public:
                                                        ScrollArrow(BRect frame);
        virtual                                 ~ScrollArrow();

                        bool                    IsEnabled() const { return fEnabled; };
                        void                    SetEnabled(bool enabled);

private:
                        bool                    fEnabled;
};


class UpScrollArrow : public ScrollArrow {
public:
                                                        UpScrollArrow(BRect frame);
        virtual                                 ~UpScrollArrow();

        virtual void                    Draw(BRect updateRect);
        virtual void                    MouseDown(BPoint where);
};


class DownScrollArrow : public ScrollArrow {
public:
                                                        DownScrollArrow(BRect frame);
        virtual                                 ~DownScrollArrow();

        virtual void                    Draw(BRect updateRect);
        virtual void                    MouseDown(BPoint where);
};


class LeftScrollArrow : public ScrollArrow {
public:
                                                        LeftScrollArrow(BRect frame);
        virtual                                 ~LeftScrollArrow();

        virtual void                    Draw(BRect updateRect);
        virtual void                    MouseDown(BPoint where);
};


class RightScrollArrow : public ScrollArrow {
public:
                                                        RightScrollArrow(BRect frame);
        virtual                                 ~RightScrollArrow();

        virtual void                    Draw(BRect updateRect);
        virtual void                    MouseDown(BPoint where);
};


//      #pragma mark -


ScrollArrow::ScrollArrow(BRect frame)
        :
        BView(frame, "menu scroll arrow", B_FOLLOW_NONE, B_WILL_DRAW),
        fEnabled(false)
{
        SetViewUIColor(B_MENU_BACKGROUND_COLOR);
}


ScrollArrow::~ScrollArrow()
{
}


void
ScrollArrow::SetEnabled(bool enabled)
{
        fEnabled = enabled;
        Invalidate();
}


//      #pragma mark -


UpScrollArrow::UpScrollArrow(BRect frame)
        :
        ScrollArrow(frame)
{
}


UpScrollArrow::~UpScrollArrow()
{
}


void
UpScrollArrow::Draw(BRect updateRect)
{
        SetLowColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR),
                B_DARKEN_1_TINT));

        if (IsEnabled())
                SetHighColor(0, 0, 0);
        else {
                SetHighColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR),
                        B_DARKEN_2_TINT));
        }

        FillRect(Bounds(), B_SOLID_LOW);

        float middle = Bounds().right / 2;
        FillTriangle(BPoint(middle, (kScrollerDimension / 2) - 3),
                BPoint(middle + 5, (kScrollerDimension / 2) + 2),
                BPoint(middle - 5, (kScrollerDimension / 2) + 2));
}


void
UpScrollArrow::MouseDown(BPoint where)
{
        if (!IsEnabled())
                return;

        TInlineScrollView* parent = dynamic_cast<TInlineScrollView*>(Parent());
        if (parent == NULL)
                return;

        float smallStep;
        float largeStep;
        parent->GetSteps(&smallStep, &largeStep);

        BMessage* message = Window()->CurrentMessage();
        int32 modifiers = 0;
        message->FindInt32("modifiers", &modifiers);
        // pressing the shift key scrolls faster
        if ((modifiers & B_SHIFT_KEY) != 0)
                parent->ScrollBy(-largeStep);
        else
                parent->ScrollBy(-smallStep);

        snooze(5000);
}


//      #pragma mark -


DownScrollArrow::DownScrollArrow(BRect frame)
        :
        ScrollArrow(frame)
{
}


DownScrollArrow::~DownScrollArrow()
{
}


void
DownScrollArrow::Draw(BRect updateRect)
{
        SetLowColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR),
                B_DARKEN_1_TINT));

        if (IsEnabled())
                SetHighColor(0, 0, 0);
        else {
                SetHighColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR),
                        B_DARKEN_2_TINT));
        }

        BRect frame = Bounds();
        FillRect(frame, B_SOLID_LOW);

        float middle = Bounds().right / 2;
        FillTriangle(BPoint(middle, frame.bottom - (kScrollerDimension / 2) + 3),
                BPoint(middle + 5, frame.bottom - (kScrollerDimension / 2) - 2),
                BPoint(middle - 5, frame.bottom - (kScrollerDimension / 2) - 2));
}


void
DownScrollArrow::MouseDown(BPoint where)
{
        if (!IsEnabled())
                return;

        TInlineScrollView* grandparent
                = dynamic_cast<TInlineScrollView*>(Parent()->Parent());
        if (grandparent == NULL)
                return;

        float smallStep;
        float largeStep;
        grandparent->GetSteps(&smallStep, &largeStep);

        BMessage* message = Window()->CurrentMessage();
        int32 modifiers = 0;
        message->FindInt32("modifiers", &modifiers);
        // pressing the shift key scrolls faster
        if ((modifiers & B_SHIFT_KEY) != 0)
                grandparent->ScrollBy(largeStep);
        else
                grandparent->ScrollBy(smallStep);

        snooze(5000);
}


//      #pragma mark -


LeftScrollArrow::LeftScrollArrow(BRect frame)
        :
        ScrollArrow(frame)
{
}


LeftScrollArrow::~LeftScrollArrow()
{
}


void
LeftScrollArrow::Draw(BRect updateRect)
{
        SetLowColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR), B_DARKEN_1_TINT));

        if (IsEnabled())
                SetHighColor(0, 0, 0);
        else {
                SetHighColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR),
                        B_DARKEN_2_TINT));
        }

        FillRect(Bounds(), B_SOLID_LOW);

        float middle = Bounds().bottom / 2;
        FillTriangle(BPoint((kScrollerDimension / 2) - 3, middle),
                BPoint((kScrollerDimension / 2) + 2, middle + 5),
                BPoint((kScrollerDimension / 2) + 2, middle - 5));
}


void
LeftScrollArrow::MouseDown(BPoint where)
{
        if (!IsEnabled())
                return;

        TInlineScrollView* parent = dynamic_cast<TInlineScrollView*>(Parent());
        if (parent == NULL)
                return;

        float smallStep;
        float largeStep;
        parent->GetSteps(&smallStep, &largeStep);

        BMessage* message = Window()->CurrentMessage();
        int32 modifiers = 0;
        message->FindInt32("modifiers", &modifiers);
        // pressing the shift key scrolls faster
        if ((modifiers & B_SHIFT_KEY) != 0)
                parent->ScrollBy(-largeStep);
        else
                parent->ScrollBy(-smallStep);

        snooze(5000);
}


//      #pragma mark -


RightScrollArrow::RightScrollArrow(BRect frame)
        :
        ScrollArrow(frame)
{
}


RightScrollArrow::~RightScrollArrow()
{
}


void
RightScrollArrow::Draw(BRect updateRect)
{
        SetLowColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR), B_DARKEN_1_TINT));

        if (IsEnabled())
                SetHighColor(0, 0, 0);
        else {
                SetHighColor(tint_color(ui_color(B_MENU_BACKGROUND_COLOR),
                        B_DARKEN_2_TINT));
        }

        BRect frame = Bounds();
        FillRect(frame, B_SOLID_LOW);

        float middle = Bounds().bottom / 2;
        FillTriangle(BPoint(kScrollerDimension / 2 + 3, middle),
                BPoint(kScrollerDimension / 2 - 2, middle + 5),
                BPoint(kScrollerDimension / 2 - 2, middle - 5));
}


void
RightScrollArrow::MouseDown(BPoint where)
{
        if (!IsEnabled())
                return;

        TInlineScrollView* grandparent
                = dynamic_cast<TInlineScrollView*>(Parent()->Parent());
        if (grandparent == NULL)
                return;

        float smallStep;
        float largeStep;
        grandparent->GetSteps(&smallStep, &largeStep);

        BMessage* message = Window()->CurrentMessage();
        int32 modifiers = 0;
        message->FindInt32("modifiers", &modifiers);
        // pressing the shift key scrolls faster
        if ((modifiers & B_SHIFT_KEY) != 0)
                grandparent->ScrollBy(largeStep);
        else
                grandparent->ScrollBy(smallStep);

        snooze(5000);
}


//      #pragma mark -


TInlineScrollView::TInlineScrollView(BView* target,
        enum orientation orientation)
        :
        BView(BRect(0, 0, 0, 0), "inline scroll view", B_FOLLOW_NONE, B_WILL_DRAW),
        fTarget(target),
        fBeginScrollArrow(NULL),
        fEndScrollArrow(NULL),
        fScrollStep(kDefaultScrollStep),
        fScrollValue(0),
        fScrollLimit(0),
        fOrientation(orientation)
{
}


TInlineScrollView::~TInlineScrollView()
{
        if (fBeginScrollArrow != NULL) {
                fBeginScrollArrow->RemoveSelf();
                delete fBeginScrollArrow;
                fBeginScrollArrow = NULL;
        }

        if (fEndScrollArrow != NULL) {
                fEndScrollArrow->RemoveSelf();
                delete fEndScrollArrow;
                fEndScrollArrow = NULL;
        }
}


void
TInlineScrollView::AttachedToWindow()
{
        BView::AttachedToWindow();

        if (fTarget == NULL)
                return;

        AddChild(fTarget);
        fTarget->MoveTo(0, 0);
}


void
TInlineScrollView::DetachedFromWindow()
{
        BView::DetachedFromWindow();

        if (fTarget != NULL)
                fTarget->RemoveSelf();

        if (fBeginScrollArrow != NULL)
                fBeginScrollArrow->RemoveSelf();

        if (fEndScrollArrow != NULL)
                fEndScrollArrow->RemoveSelf();
}


void
TInlineScrollView::Draw(BRect updateRect)
{
        BRect frame = Bounds();
        be_control_look->DrawButtonBackground(this, frame, updateRect,
                ui_color(B_MENU_BACKGROUND_COLOR));
}


//      #pragma mark -


void
TInlineScrollView::AttachScrollers()
{
        if (fTarget == NULL)
                return;

        BRect frame = Bounds();

        if (HasScrollers()) {
                if (fOrientation == B_VERTICAL) {
                        fScrollLimit = fTarget->Bounds().Height()
                                - (frame.Height() - 2 * kScrollerDimension);
                } else {
                        fScrollLimit = fTarget->Bounds().Width()
                                - (frame.Width() - 2 * kScrollerDimension);
                }

                if (fScrollValue > fScrollLimit) {
                        // If scroll value is above limit scroll back
                        float delta = fScrollLimit - fScrollValue;
                        if (fOrientation == B_VERTICAL)
                                fTarget->ScrollBy(0, delta);
                        else
                                fTarget->ScrollBy(delta, 0);

                        fScrollValue = fScrollLimit;
                }
                return;
        }

        fTarget->MakeFocus(true);

        if (fOrientation == B_VERTICAL) {
                if (fBeginScrollArrow == NULL) {
                        fBeginScrollArrow = new UpScrollArrow(
                                BRect(frame.left, frame.top, frame.right,
                                        kScrollerDimension - 1));
                        AddChild(fBeginScrollArrow);
                }

                if (fEndScrollArrow == NULL) {
                        fEndScrollArrow = new DownScrollArrow(
                                BRect(0, frame.bottom - 2 * kScrollerDimension + 1, frame.right,
                                        frame.bottom - kScrollerDimension));
                        fTarget->AddChild(fEndScrollArrow);
                }

                fTarget->MoveBy(0, kScrollerDimension);

                fScrollLimit = fTarget->Bounds().Height()
                        - (frame.Height() - 2 * kScrollerDimension);
        } else {
                if (fBeginScrollArrow == NULL) {
                        fBeginScrollArrow = new LeftScrollArrow(
                                BRect(frame.left, frame.top,
                                        frame.left + kScrollerDimension - 1, frame.bottom));
                        AddChild(fBeginScrollArrow);
                }

                if (fEndScrollArrow == NULL) {
                        fEndScrollArrow = new RightScrollArrow(
                                BRect(frame.right - 2 * kScrollerDimension + 1, frame.top,
                                        frame.right, frame.bottom));
                        fTarget->AddChild(fEndScrollArrow);
                }

                fTarget->MoveBy(kScrollerDimension, 0);

                fScrollLimit = fTarget->Bounds().Width()
                        - (frame.Width() - 2 * kScrollerDimension);
        }

        fBeginScrollArrow->SetEnabled(false);
        fEndScrollArrow->SetEnabled(true);

        fScrollValue = 0;
}


void
TInlineScrollView::DetachScrollers()
{
        if (!HasScrollers())
                return;

        if (fEndScrollArrow) {
                fEndScrollArrow->RemoveSelf();
                delete fEndScrollArrow;
                fEndScrollArrow = NULL;
        }

        if (fBeginScrollArrow) {
                fBeginScrollArrow->RemoveSelf();
                delete fBeginScrollArrow;
                fBeginScrollArrow = NULL;
        }

        if (fTarget) {
                // We don't remember the position where the last scrolling
                // ended, so scroll back to the beginning.
                if (fOrientation == B_VERTICAL)
                        fTarget->MoveBy(0, -kScrollerDimension);
                else
                        fTarget->MoveBy(-kScrollerDimension, 0);

                fTarget->ScrollTo(0, 0);
                fScrollValue = 0;
        }
}


bool
TInlineScrollView::HasScrollers() const
{
        return fTarget != NULL && fBeginScrollArrow != NULL
                && fEndScrollArrow != NULL;
}


void
TInlineScrollView::SetSmallStep(float step)
{
        fScrollStep = step;
}


void
TInlineScrollView::GetSteps(float* _smallStep, float* _largeStep) const
{
        if (_smallStep != NULL)
                *_smallStep = fScrollStep;
        if (_largeStep != NULL) {
                *_largeStep = fScrollStep * 3;
        }
}


void
TInlineScrollView::ScrollBy(const float& step)
{
        if (!HasScrollers())
                return;

        if (step > 0) {
                if (fScrollValue == 0)
                        fBeginScrollArrow->SetEnabled(true);

                if (fScrollValue + step >= fScrollLimit) {
                        // If we reached the limit, only scroll to the end
                        if (fOrientation == B_VERTICAL) {
                                fTarget->ScrollBy(0, fScrollLimit - fScrollValue);
                                fEndScrollArrow->MoveBy(0, fScrollLimit - fScrollValue);
                        } else {
                                fTarget->ScrollBy(fScrollLimit - fScrollValue, 0);
                                fEndScrollArrow->MoveBy(fScrollLimit - fScrollValue, 0);
                        }
                        fEndScrollArrow->SetEnabled(false);
                        fScrollValue = fScrollLimit;
                } else {
                        if (fOrientation == B_VERTICAL) {
                                fTarget->ScrollBy(0, step);
                                fEndScrollArrow->MoveBy(0, step);
                        } else {
                                fTarget->ScrollBy(step, 0);
                                fEndScrollArrow->MoveBy(step, 0);
                        }
                        fScrollValue += step;
                }
        } else if (step < 0) {
                if (fScrollValue == fScrollLimit)
                        fEndScrollArrow->SetEnabled(true);

                if (fScrollValue + step <= 0) {
                        if (fOrientation == B_VERTICAL) {
                                fTarget->ScrollBy(0, -fScrollValue);
                                fEndScrollArrow->MoveBy(0, -fScrollValue);
                        } else {
                                fTarget->ScrollBy(-fScrollValue, 0);
                                fEndScrollArrow->MoveBy(-fScrollValue, 0);
                        }
                        fBeginScrollArrow->SetEnabled(false);
                        fScrollValue = 0;
                } else {
                        if (fOrientation == B_VERTICAL) {
                                fTarget->ScrollBy(0, step);
                                fEndScrollArrow->MoveBy(0, step);
                        } else {
                                fTarget->ScrollBy(step, 0);
                                fEndScrollArrow->MoveBy(step, 0);
                        }
                        fScrollValue += step;
                }
        }

        //fTarget->Invalidate();
}