/*
 * Copyright 2006-2007, 2011, Stephan Aßmus <superstippi@gmx.de>
 * All rights reserved. Distributed under the terms of the MIT License.
 */


#include "CanvasView.h"

#include <Bitmap.h>
#include <Cursor.h>
#include <Message.h>
#include <Region.h>
#include <Window.h>

#include <stdio.h>

#include "cursors.h"
#include "ui_defines.h"

#include "CommandStack.h"
#include "IconRenderer.h"


using std::nothrow;


CanvasView::CanvasView(BRect frame)
        :
        StateView(frame, "canvas view", B_FOLLOW_ALL,
                B_WILL_DRAW | B_FRAME_EVENTS),
        fBitmap(new BBitmap(BRect(0, 0, 63, 63), 0, B_RGB32)),
        fBackground(new BBitmap(BRect(0, 0, 63, 63), 0, B_RGB32)),
        fIcon(NULL),
        fRenderer(new IconRenderer(fBitmap)),
        fDirtyIconArea(fBitmap->Bounds()),

        fCanvasOrigin(0.0, 0.0),
        fZoomLevel(8.0),

        fSpaceHeldDown(false),
        fInScrollTo(false),
        fScrollTracking(false),
        fScrollTrackingStart(0.0, 0.0),

        fMouseFilterMode(SNAPPING_OFF)
{
        _MakeBackground();
        fRenderer->SetBackground(fBackground);
}


CanvasView::~CanvasView()
{
        SetIcon(NULL);
        delete fRenderer;
        delete fBitmap;
        delete fBackground;
}


// #pragma mark -


void
CanvasView::AttachedToWindow()
{
        StateView::AttachedToWindow();

        SetViewColor(B_TRANSPARENT_COLOR);
        SetLowColor(kStripesHigh);
        SetHighColor(kStripesLow);

        // init data rect for scrolling and center bitmap in the view
        BRect dataRect = _LayoutCanvas();
        SetDataRect(dataRect);
        BRect bounds(Bounds());
        BPoint dataRectCenter((dataRect.left + dataRect.right) / 2,
                (dataRect.top + dataRect.bottom) / 2);
        BPoint boundsCenter((bounds.left + bounds.right) / 2,
                (bounds.top + bounds.bottom) / 2);
        BPoint offset = ScrollOffset();
        offset.x = roundf(offset.x + dataRectCenter.x - boundsCenter.x);
        offset.y = roundf(offset.y + dataRectCenter.y - boundsCenter.y);
        SetScrollOffset(offset);
}


void
CanvasView::FrameResized(float width, float height)
{
        // keep canvas centered
        BPoint oldCanvasOrigin = fCanvasOrigin;
        SetDataRect(_LayoutCanvas());
        if (oldCanvasOrigin != fCanvasOrigin)
                Invalidate();
}


void
CanvasView::Draw(BRect updateRect)
{
        _DrawInto(this, updateRect);
}


// #pragma mark -


void
CanvasView::MouseDown(BPoint where)
{
        if (!IsFocus())
                MakeFocus(true);

        int32 buttons;
        if (Window()->CurrentMessage()->FindInt32("buttons", &buttons) < B_OK)
                buttons = 0;

        // handle clicks of the third mouse button ourselves (panning),
        // otherwise have StateView handle it (normal clicks)
        if (fSpaceHeldDown || (buttons & B_TERTIARY_MOUSE_BUTTON) != 0) {
                // switch into scrolling mode and update cursor
                fScrollTracking = true;
                where.x = roundf(where.x);
                where.y = roundf(where.y);
                fScrollOffsetStart = ScrollOffset();
                fScrollTrackingStart = where - fScrollOffsetStart;
                _UpdateToolCursor();
                SetMouseEventMask(B_POINTER_EVENTS,
                        B_LOCK_WINDOW_FOCUS | B_SUSPEND_VIEW_FOCUS);
        } else {
                StateView::MouseDown(where);
        }
}


void
CanvasView::MouseUp(BPoint where)
{
        if (fScrollTracking) {
                // stop scroll tracking and update cursor
                fScrollTracking = false;
                _UpdateToolCursor();
                // update StateView mouse position
                uint32 transit = Bounds().Contains(where) ?
                        B_INSIDE_VIEW : B_OUTSIDE_VIEW;
                StateView::MouseMoved(where, transit, NULL);
        } else {
                StateView::MouseUp(where);
        }
}


void
CanvasView::MouseMoved(BPoint where, uint32 transit, const BMessage* dragMessage)
{
        if (fScrollTracking) {
                uint32 buttons;
                GetMouse(&where, &buttons, false);
                if (!buttons) {
                        MouseUp(where);
                        return;
                }
                where.x = roundf(where.x);
                where.y = roundf(where.y);
                where -= ScrollOffset();
                BPoint offset = where - fScrollTrackingStart;
                SetScrollOffset(fScrollOffsetStart - offset);
        } else {
                // normal mouse movement handled by StateView
                if (!fSpaceHeldDown)
                        StateView::MouseMoved(where, transit, dragMessage);
        }
}


void
CanvasView::FilterMouse(BPoint* where) const
{
        switch (fMouseFilterMode) {

                case SNAPPING_64:
                        ConvertToCanvas(where);
                        where->x = floorf(where->x + 0.5);
                        where->y = floorf(where->y + 0.5);
                        ConvertFromCanvas(where);
                        break;

                case SNAPPING_32:
                        ConvertToCanvas(where);
                        where->x /= 2.0;
                        where->y /= 2.0;
                        where->x = floorf(where->x + 0.5);
                        where->y = floorf(where->y + 0.5);
                        where->x *= 2.0;
                        where->y *= 2.0;
                        ConvertFromCanvas(where);
                        break;

                case SNAPPING_16:
                        ConvertToCanvas(where);
                        where->x /= 4.0;
                        where->y /= 4.0;
                        where->x = floorf(where->x + 0.5);
                        where->y = floorf(where->y + 0.5);
                        where->x *= 4.0;
                        where->y *= 4.0;
                        ConvertFromCanvas(where);
                        break;

                case SNAPPING_OFF:
                default:
                        break;
        }
}


bool
CanvasView::MouseWheelChanged(BPoint where, float x, float y)
{
        if (!Bounds().Contains(where))
                return false;

        if (y > 0.0) {
                _SetZoom(_NextZoomOutLevel(fZoomLevel), true);
                return true;
        } else if (y < 0.0) {
                _SetZoom(_NextZoomInLevel(fZoomLevel), true);
                return true;
        }
        return false;
}


// #pragma mark -


void
CanvasView::SetScrollOffset(BPoint newOffset)
{
        if (fInScrollTo)
                return;

        fInScrollTo = true;

        newOffset = ValidScrollOffsetFor(newOffset);
        if (!fScrollTracking) {
                BPoint mouseOffset = newOffset - ScrollOffset();
                MouseMoved(fMouseInfo.position + mouseOffset, fMouseInfo.transit,
                        NULL);
        }

        Scrollable::SetScrollOffset(newOffset);

        fInScrollTo = false;
}


void
CanvasView::ScrollOffsetChanged(BPoint oldOffset, BPoint newOffset)
{
        BPoint offset = newOffset - oldOffset;

        if (offset == B_ORIGIN) {
                // prevent circular code (MouseMoved might call ScrollBy...)
                return;
        }

        ScrollBy(offset.x, offset.y);
}


void
CanvasView::VisibleSizeChanged(float oldWidth, float oldHeight, float newWidth,
        float newHeight)
{
        BRect dataRect(_LayoutCanvas());
        SetDataRect(dataRect);
}


// #pragma mark -


void
CanvasView::AreaInvalidated(const BRect& area)
{
        if (fDirtyIconArea.Contains(area))
                return;

        fDirtyIconArea = fDirtyIconArea | area;

        BRect viewArea(area);
        ConvertFromCanvas(&viewArea);
        Invalidate(viewArea);
}


// #pragma mark -


void
CanvasView::SetIcon(Icon* icon)
{
        if (fIcon == icon)
                return;

        if (fIcon)
                fIcon->RemoveListener(this);

        fIcon = icon;
        fRenderer->SetIcon(icon);

        if (fIcon)
                fIcon->AddListener(this);
}


void
CanvasView::SetMouseFilterMode(uint32 mode)
{
        if (fMouseFilterMode == mode)
                return;

        fMouseFilterMode = mode;
        Invalidate(_CanvasRect());
}


void
CanvasView::ConvertFromCanvas(BPoint* point) const
{
        point->x = point->x * fZoomLevel + fCanvasOrigin.x;
        point->y = point->y * fZoomLevel + fCanvasOrigin.y;
}


void
CanvasView::ConvertToCanvas(BPoint* point) const
{
        point->x = (point->x - fCanvasOrigin.x) / fZoomLevel;
        point->y = (point->y - fCanvasOrigin.y) / fZoomLevel;
}


void
CanvasView::ConvertFromCanvas(BRect* r) const
{
        r->left = r->left * fZoomLevel + fCanvasOrigin.x;
        r->top = r->top * fZoomLevel + fCanvasOrigin.y;
        r->right++;
        r->bottom++;
        r->right = r->right * fZoomLevel + fCanvasOrigin.x;
        r->bottom = r->bottom * fZoomLevel + fCanvasOrigin.y;
        r->right--;
        r->bottom--;
}


void
CanvasView::ConvertToCanvas(BRect* r) const
{
        r->left = (r->left - fCanvasOrigin.x) / fZoomLevel;
        r->top = (r->top - fCanvasOrigin.y) / fZoomLevel;
        r->right = (r->right - fCanvasOrigin.x) / fZoomLevel;
        r->bottom = (r->bottom - fCanvasOrigin.y) / fZoomLevel;
}


// #pragma mark -


bool
CanvasView::_HandleKeyDown(uint32 key, uint32 modifiers)
{
        switch (key) {
                case 'z':
                case 'y':
                        if (modifiers & B_SHIFT_KEY)
                                CommandStack()->Redo();
                        else
                                CommandStack()->Undo();
                        break;

                case '+':
                        _SetZoom(_NextZoomInLevel(fZoomLevel));
                        break;
                case '-':
                        _SetZoom(_NextZoomOutLevel(fZoomLevel));
                        break;

                case B_SPACE:
                        fSpaceHeldDown = true;
                        _UpdateToolCursor();
                        break;

                default:
                        return StateView::_HandleKeyDown(key, modifiers);
        }

        return true;
}


bool
CanvasView::_HandleKeyUp(uint32 key, uint32 modifiers)
{
        switch (key) {
                case B_SPACE:
                        fSpaceHeldDown = false;
                        _UpdateToolCursor();
                        break;

                default:
                        return StateView::_HandleKeyUp(key, modifiers);
        }

        return true;
}


BRect
CanvasView::_CanvasRect() const
{
        BRect r;
        if (fBitmap == NULL)
                return r;
        r = fBitmap->Bounds();
        ConvertFromCanvas(&r);
        return r;
}


void
CanvasView::_DrawInto(BView* view, BRect updateRect)
{
        if (fDirtyIconArea.IsValid()) {
                fRenderer->Render(fDirtyIconArea, true);
                fDirtyIconArea.Set(LONG_MAX, LONG_MAX, LONG_MIN, LONG_MIN);
        }

        // icon
        BRect canvas(_CanvasRect());
        view->DrawBitmap(fBitmap, fBitmap->Bounds(), canvas);

        // grid
        int32 gridLines = 0;
        int32 scale = 1;
        switch (fMouseFilterMode) {
                case SNAPPING_64:
                        gridLines = 63;
                        break;
                case SNAPPING_32:
                        gridLines = 31;
                        scale = 2;
                        break;
                case SNAPPING_16:
                        gridLines = 15;
                        scale = 4;
                        break;
                case SNAPPING_OFF:
                default:
                        break;
        }
        view->SetDrawingMode(B_OP_BLEND);
        for (int32 i = 1; i <= gridLines; i++) {
                BPoint cross(i * scale, i * scale);
                ConvertFromCanvas(&cross);
                view->StrokeLine(BPoint(canvas.left, cross.y),
                                                 BPoint(canvas.right, cross.y));
                view->StrokeLine(BPoint(cross.x, canvas.top),
                                                 BPoint(cross.x, canvas.bottom));
        }
        view->SetDrawingMode(B_OP_COPY);

        // outside icon
        BRegion outside(Bounds() & updateRect);
        outside.Exclude(canvas);
        view->FillRegion(&outside, kStripes);

        StateView::Draw(view, updateRect);
}


void
CanvasView::_MakeBackground()
{
        uint8* row = (uint8*)fBackground->Bits();
        uint32 bpr = fBackground->BytesPerRow();
        uint32 width = fBackground->Bounds().IntegerWidth() + 1;
        uint32 height = fBackground->Bounds().IntegerHeight() + 1;

        const GammaTable& lut = fRenderer->GammaTable();
        uint8 redLow = lut.dir(kAlphaLow.red);
        uint8 greenLow = lut.dir(kAlphaLow.blue);
        uint8 blueLow = lut.dir(kAlphaLow.green);
        uint8 redHigh = lut.dir(kAlphaHigh.red);
        uint8 greenHigh = lut.dir(kAlphaHigh.blue);
        uint8 blueHigh = lut.dir(kAlphaHigh.green);

        for (uint32 y = 0; y < height; y++) {
                uint8* p = row;
                for (uint32 x = 0; x < width; x++) {
                        p[3] = 255;
                        if (x % 8 >= 4) {
                                if (y % 8 >= 4) {
                                        p[0] = blueLow;
                                        p[1] = greenLow;
                                        p[2] = redLow;
                                } else {
                                        p[0] = blueHigh;
                                        p[1] = greenHigh;
                                        p[2] = redHigh;
                                }
                        } else {
                                if (y % 8 >= 4) {
                                        p[0] = blueHigh;
                                        p[1] = greenHigh;
                                        p[2] = redHigh;
                                } else {
                                        p[0] = blueLow;
                                        p[1] = greenLow;
                                        p[2] = redLow;
                                }
                        }
                        p += 4;
                }
                row += bpr;
        }
}


void
CanvasView::_UpdateToolCursor()
{
        if (fIcon) {
                if (fScrollTracking || fSpaceHeldDown) {
                        // indicate scrolling mode
                        const uchar* cursorData = fScrollTracking ? kGrabCursor : kHandCursor;
                        BCursor cursor(cursorData);
                        SetViewCursor(&cursor, true);
                } else {
                        // pass on to current state of StateView
                        UpdateStateCursor();
                }
        } else {
                BCursor cursor(kStopCursor);
                SetViewCursor(&cursor, true);
        }
}


// #pragma mark -


double
CanvasView::_NextZoomInLevel(double zoom) const
{
        if (zoom < 1)
                return 1;
        if (zoom < 1.5)
                return 1.5;
        if (zoom < 2)
                return 2;
        if (zoom < 3)
                return 3;
        if (zoom < 4)
                return 4;
        if (zoom < 6)
                return 6;
        if (zoom < 8)
                return 8;
        if (zoom < 16)
                return 16;
        if (zoom < 32)
                return 32;
        return 64;
}


double
CanvasView::_NextZoomOutLevel(double zoom) const
{
        if (zoom > 32)
                return 32;
        if (zoom > 16)
                return 16;
        if (zoom > 8)
                return 8;
        if (zoom > 6)
                return 6;
        if (zoom > 4)
                return 4;
        if (zoom > 3)
                return 3;
        if (zoom > 2)
                return 2;
        if (zoom > 1.5)
                return 1.5;
        return 1;
}


void
CanvasView::_SetZoom(double zoomLevel, bool mouseIsAnchor)
{
        if (fZoomLevel == zoomLevel)
                return;

        BPoint anchor;
        if (mouseIsAnchor) {
                // zoom into mouse position
                anchor = MouseInfo()->position;
        } else {
                // zoom into center of view
                BRect bounds(Bounds());
                anchor.x = (bounds.left + bounds.right + 1) / 2.0;
                anchor.y = (bounds.top + bounds.bottom + 1) / 2.0;
        }

        BPoint canvasAnchor = anchor;
        ConvertToCanvas(&canvasAnchor);

        fZoomLevel = zoomLevel;
        BRect dataRect = _LayoutCanvas();

        ConvertFromCanvas(&canvasAnchor);

        BPoint offset = ScrollOffset();
        offset.x = roundf(offset.x + canvasAnchor.x - anchor.x);
        offset.y = roundf(offset.y + canvasAnchor.y - anchor.y);

        Invalidate();

        SetDataRectAndScrollOffset(dataRect, offset);
}


BRect
CanvasView::_LayoutCanvas()
{
        // size of zoomed bitmap
        BRect r(_CanvasRect());
        r.OffsetTo(B_ORIGIN);

        // ask current view state to extend size
        // TODO: Ask StateViewState to extend bounds...
        BRect stateBounds = r; //ViewStateBounds();

        // resize for empty area around bitmap
        // (the size we want, but might still be much smaller than view)
        r.InsetBy(-50, -50);

        // center data rect in bounds
        BRect bounds(Bounds());
        if (bounds.Width() > r.Width())
                r.InsetBy(-ceilf((bounds.Width() - r.Width()) / 2), 0);
        if (bounds.Height() > r.Height())
                r.InsetBy(0, -ceilf((bounds.Height() - r.Height()) / 2));

        if (stateBounds.IsValid()) {
                stateBounds.InsetBy(-20, -20);
                r = r | stateBounds;
        }

        return r;
}