/*
 * Copyright 2003-2009, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Jonas Sundström, jonas@kirilla.com
 */


#include "ZipOMaticActivity.h"

#include <ControlLook.h>

#include <stdio.h>


Activity::Activity(const char* name)
        :
        BView(name, B_WILL_DRAW | B_FRAME_EVENTS),
        fIsRunning(false),
        fBitmap(NULL),
        fSpinSpeed(0.15),
        fColors(NULL),
        fNumColors(0),
        fScrollOffset(0.0),
        fStripeWidth(0.0),
        fNumStripes(0)
{
        _InactiveColors();
        SetExplicitMinSize(BSize(17, 17));
        SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, 17));
};


Activity::~Activity()
{
        delete fBitmap;
        delete[] fColors;
}


void 
Activity::AllAttached()
{
        _CreateBitmap();
        FrameResized(Bounds().Width(), Bounds().Height());
}


void 
Activity::Start()
{
        fIsRunning = true;
        _ActiveColors();
        Window()->SetPulseRate(100000);
        SetFlags(Flags() | B_PULSE_NEEDED);
        Invalidate();
}


void 
Activity::Pause()
{
        Window()->SetPulseRate(500000);
        SetFlags(Flags() & (~B_PULSE_NEEDED));
        Invalidate();
}


void 
Activity::Stop()
{
        fIsRunning = false;
        _InactiveColors();
        Window()->SetPulseRate(500000);
        SetFlags(Flags() & (~B_PULSE_NEEDED));
        Invalidate();
}


bool 
Activity::IsRunning()   
{
        return fIsRunning;
}


void 
Activity::Pulse()
{
        fScrollOffset += fStripeWidth / (1.0f / fSpinSpeed);
        if (fScrollOffset >= fStripeWidth * fNumColors) {
                // Cycle completed, jump back to where we started
                fScrollOffset = 0;
        }
        Invalidate();
}


void
Activity::SetColors(const rgb_color* colors, uint32 numColors)
{
        delete[] fColors;
        rgb_color* colorsCopy = new rgb_color[numColors];
        for (uint32 i = 0; i < numColors; i++)
                colorsCopy[i] = colors[i];

        fColors = colorsCopy;
        fNumColors = numColors;
}


void 
Activity::Draw(BRect rect)
{
        BRect viewRect = Bounds();
        BRect bitmapRect = fBitmap->Bounds();

        if (bitmapRect != viewRect) {
                delete fBitmap;
                _CreateBitmap();
        }

        _DrawOnBitmap(IsRunning());
        SetDrawingMode(B_OP_COPY);
        DrawBitmap(fBitmap);
}


void
Activity::_DrawOnBitmap(bool running)
{
        if (fBitmap->Lock()) {
                BRect bounds = fBitmap->Bounds();

                fBitmapView->SetDrawingMode(B_OP_COPY);
        
                // Draw color stripes
                float position = -fStripeWidth * (fNumColors + 0.5) + fScrollOffset;
                // Starting position: beginning of the second color cycle
                // The + 0.5 is so we start out without a partially visible stripe
                // on the left side (makes it simpler to loop)
                BRect innerFrame = bounds;
                innerFrame.InsetBy(-2, -2);

                be_control_look->DrawStatusBar(fBitmapView, innerFrame, innerFrame,
                        ui_color(B_PANEL_BACKGROUND_COLOR),
                        running ? ui_color(B_STATUS_BAR_COLOR)
                                : ui_color(B_PANEL_BACKGROUND_COLOR),
                        bounds.Width());
                fBitmapView->SetDrawingMode(B_OP_ALPHA);
                uint32 colorIndex = 0;
                for (uint32 i = 0; i < fNumStripes; i++) {
                        fBitmapView->SetHighColor(fColors[colorIndex]);
                        colorIndex++;
                        if (colorIndex >= fNumColors)
                                colorIndex = 0;

                        BRect stripeFrame = fStripe.Frame();
                        fStripe.MapTo(stripeFrame,
                        stripeFrame.OffsetToCopy(position, 0.0));
                        fBitmapView->FillPolygon(&fStripe);

                        position += fStripeWidth;
                }

                fBitmapView->SetDrawingMode(B_OP_COPY);
                // Draw box around it
                be_control_look->DrawTextControlBorder(fBitmapView, bounds, bounds,
                        ui_color(B_PANEL_BACKGROUND_COLOR), B_PLAIN_BORDER);
                
                fBitmapView->Sync();
                fBitmap->Unlock();
        }
}


void
Activity::_CreateBitmap(void)
{
        BRect rect = Bounds();
        fBitmap = new BBitmap(rect, B_RGBA32, true);
        fBitmapView = new BView(Bounds(), "buffer", B_FOLLOW_NONE, 0);
        fBitmap->AddChild(fBitmapView);
}


void
Activity::FrameResized(float width, float height)
{
        delete fBitmap;
        _CreateBitmap();
        // Choose stripe width so that at least 2 full stripes fit into the view,
        // but with a minimum of 5px. Larger views get wider stripes, but they
        // grow slower than the view and are capped to a maximum of 200px.
        fStripeWidth = (width / (fIsRunning ? 4 : 6)) + 5;
        if (fStripeWidth > 200)
                fStripeWidth = 200;

        BPoint stripePoints[4];
        stripePoints[0].Set(fStripeWidth * 0.5, 0.0); // top left
        stripePoints[1].Set(fStripeWidth * 1.5, 0.0); // top right
        stripePoints[2].Set(fStripeWidth, height);    // bottom right
        stripePoints[3].Set(0.0, height);             // bottom left

        fStripe = BPolygon(stripePoints, 4);

        fNumStripes = (int32)ceilf((width) / fStripeWidth) + 1 + fNumColors;
                // Number of color stripes drawn in total for the barber pole, the
                // user-visible part is a "window" onto the complete pole. We need
                // as many stripes as are visible, an extra one on the right side
                // (will be partially visible, that's the + 1); and then a whole color
                // cycle of strips extra which we scroll into until we loop.
                //
                // Example with 3 colors and a visible area of 2*fStripeWidth (which means
                // that 2 will be fully visible, and a third one partially):
                //               ........
                //   X___________v______v___
                //  / 1 / 2 / 3 / 1 / 2 / 3 /
                //  `````````````````````````
                // Pole is scrolled to the right into the visible region, which is marked
                // between the two 'v'. Once the left edge of the visible area reaches
                // point X, we can jump back to the initial region position.
        Invalidate();
}

void
Activity::_ActiveColors()
{
        // Default colors, chosen from system color scheme
        rgb_color defaultColors[2];
        rgb_color otherColor = tint_color(ui_color(B_STATUS_BAR_COLOR), 1.3);
        otherColor.alpha = 50;
        defaultColors[0] = otherColor;
        defaultColors[1] = B_TRANSPARENT_COLOR;
        SetColors(defaultColors, 2);

}


void
Activity::_InactiveColors()
{
        // Default colors, chosen from system color scheme
        rgb_color defaultColors[2];
        rgb_color otherColor = tint_color(ui_color(B_PANEL_BACKGROUND_COLOR), 1.7);
        otherColor.alpha = 50;
        defaultColors[0] = otherColor;
        defaultColors[1] = B_TRANSPARENT_COLOR;
        SetColors(defaultColors, 2);
}