// States.cpp

#include <View.h>

#include "States.h"

// constructor
State::State()
        : fValid(false),
          fEditing(true),
          fTracking(TRACKING_NONE),
          fStartPoint(-1.0, -1.0),
          fEndPoint(-1.0, -1.0),
          fColor((rgb_color){ 0, 0, 0, 255 }),
          fDrawingMode(B_OP_COPY),
          fFill(true),
          fPenSize(1.0)
{
}

// destructor
State::~State()
{
}

// Init
void
State::Init(rgb_color color, drawing_mode mode, bool fill, float penSize)
{
        fColor = color;
        fDrawingMode = mode;
        fFill = fill;
        fPenSize = penSize;
}

// MouseDown
void
State::MouseDown(BPoint where)
{
        where.x = floorf(where.x + 0.5);
        where.y = floorf(where.y + 0.5);

        if (_HitTest(where, fStartPoint)) {
                fTracking = TRACKING_START;
                fClickOffset = fStartPoint - where;
        } else if (_HitTest(where, fEndPoint)) {
                fTracking = TRACKING_END;
                fClickOffset = fEndPoint - where;
        } else if (!fValid) {
                fTracking = TRACKING_END;
                fStartPoint = fEndPoint = where;
                fClickOffset.Set(0.0, 0.0);
        }
}

// MouseUp
void
State::MouseUp()
{
        fTracking = TRACKING_NONE;
}

// MouseMoved
void
State::MouseMoved(BPoint where)
{
        where.x = floorf(where.x + 0.5);
        where.y = floorf(where.y + 0.5);

        if (fTracking == TRACKING_START) {
                fStartPoint = where + fClickOffset;
                fValid = true;
        } else if (fTracking == TRACKING_END) {
                fEndPoint = where + fClickOffset;
                fValid = true;
        }
}

// SetColor
void
State::SetColor(rgb_color color)
{
        fColor = color;
}

// SetDrawingMode
void
State::SetDrawingMode(drawing_mode mode)
{
        fDrawingMode = mode;
}

// SetFill
void
State::SetFill(bool fill)
{
        fFill = fill;
}

// SetPenSize
void
State::SetPenSize(float penSize)
{
        fPenSize = penSize;
}

// SetEditing
void
State::SetEditing(bool editing)
{
        fEditing = editing;
}

// Bounds
BRect
State::Bounds() const
{
        if (fValid) {
                BRect r = _ValidRect();
                float inset = -2.0; // for the dots
                if (!SupportsFill() || !fFill) {
                        inset = min_c(inset, -ceilf(fPenSize / 2.0));
                }
                r.InsetBy(inset, inset);
                return r;
        }
        return BRect(0.0, 0.0, -1.0, -1.0);
}

// Draw
void
State::Draw(BView* view) const
{
        if (fValid && fEditing) {
                _RenderDot(view, fStartPoint);
                _RenderDot(view, fEndPoint);
        }
}

// _ValidRect
BRect
State::_ValidRect() const
{
        return BRect(min_c(fStartPoint.x, fEndPoint.x),
                                 min_c(fStartPoint.y, fEndPoint.y),
                                 max_c(fStartPoint.x, fEndPoint.x),
                                 max_c(fStartPoint.y, fEndPoint.y));
}

// _RenderDot
void
State::_RenderDot(BView* view, BPoint where) const
{
        view->SetHighColor(0, 0, 0, 255);
        view->SetPenSize(1.0);
        view->SetDrawingMode(B_OP_COPY);
        BRect r(where, where);
        r.InsetBy(-2.0, -2.0);
        view->StrokeRect(r);
        view->SetHighColor(255, 255, 255, 255);
        r.InsetBy(1.0, 1.0);
        view->FillRect(r);
}

// _AdjustViewState
void
State::_AdjustViewState(BView* view) const
{
        view->SetDrawingMode(fDrawingMode);
        view->SetHighColor(fColor);

        if (!SupportsFill() || !fFill)
                view->SetPenSize(fPenSize);
}

// _HitTest
bool
State::_HitTest(BPoint where, BPoint point) const
{
        BRect r(point, point);
        r.InsetBy(-8.0, -8.0);
        return r.Contains(where);
}

// LineState
class LineState : public State {
 public:
                                        LineState()
                                                : State() {}

        virtual void    Draw(BView* view) const
                                        {
                                                if (fValid) {
                                                        _AdjustViewState(view);
                                                        view->StrokeLine(fStartPoint, fEndPoint);
                                                }
                                                State::Draw(view);
                                        }
        virtual bool    SupportsFill() const
                                        {
                                                return false;
                                        }
};

// RectState
class RectState : public State {
 public:
                                        RectState()
                                                : State() {}

        virtual void    Draw(BView* view) const
                                        {
                                                if (fValid) {
                                                        _AdjustViewState(view);
                                                        if (fFill)
                                                                view->FillRect(_ValidRect());
                                                        else
                                                                view->StrokeRect(_ValidRect());
                                                }
                                                State::Draw(view);
                                        }
};

// RoundRectState
class RoundRectState : public State {
 public:
                                        RoundRectState()
                                                : State() {}

        virtual void    Draw(BView* view) const
                                        {
                                                if (fValid) {
                                                        _AdjustViewState(view);
                                                        BRect r = _ValidRect();
                                                        float radius = min_c(r.Width() / 3.0, r.Height() / 3.0);
                                                        if (fFill)
                                                                view->FillRoundRect(r, radius, radius);
                                                        else
                                                                view->StrokeRoundRect(r, radius, radius);
                                                }
                                                State::Draw(view);
                                        }
};

// EllipseState
class EllipseState : public State {
 public:
                                        EllipseState()
                                                : State() {}

        virtual void    Draw(BView* view) const
                                        {
                                                if (fValid) {
                                                        _AdjustViewState(view);
                                                        if (fFill)
                                                                view->FillEllipse(_ValidRect());
                                                        else
                                                                view->StrokeEllipse(_ValidRect());
                                                }
                                                State::Draw(view);
                                        }
};

// StateFor
State*
State::StateFor(int32 objectType, rgb_color color, drawing_mode mode,
                                bool fill, float penSize)
{
        State* state = NULL;
        switch (objectType) {
                case OBJECT_LINE:
                        state = new LineState();
                        break;
                case OBJECT_RECT:
                        state = new RectState();
                        break;
                case OBJECT_ROUND_RECT:
                        state = new RoundRectState();
                        break;
                case OBJECT_ELLIPSE:
                        state = new EllipseState();
                        break;
                default:
                        break;
        }
        if (state)
                state->Init(color, mode, fill, penSize);
        return state;
}