#include <Application.h>
#include <GridView.h>
#include <LayoutBuilder.h>
#include <Picture.h>
#include <ScrollView.h>
#include <Shape.h>
#include <View.h>
#include <Window.h>


typedef void (*clipper)(BView*, BRect, bool);
typedef void (*test)(BView*, clipper);

static const BRect bigRect(-1000,-1000, 1000,1000);
static const BRect baseRect(-25,-10, 25,10);
static const BRect corner(-25,-10, -15,0);
static const BRect crossRect(-5,-35, 5,40);


static void
rectClipper(BView* view, BRect rect, bool inverse)
{
        if (inverse)
                view->ClipToInverseRect(rect);
        else
                view->ClipToRect(rect);
}

static void
pictureClipper(BView* view, BRect rect, bool inverse)
{
        BPicture p;
        view->BeginPicture(&p);
        view->FillEllipse(rect);
        view->SetHighColor(0, 0, 0, 0);
        view->FillEllipse(rect.InsetByCopy(rect.Width()/4, rect.Height()/4));
        view->EndPicture();

        if (inverse)
                view->ClipToInversePicture(&p);
        else
                view->ClipToPicture(&p);
}

static void
shapeClipper(BView* view, BRect rect, bool inverse)
{
        BShape s;
        s.MoveTo(rect.LeftTop());
        s.LineTo(rect.RightBottom());
        s.ArcTo(rect.Width()/4, rect.Height()/4, 0, false, true, rect.RightTop());
        s.LineTo(rect.LeftBottom());
        s.Close();

        if (inverse)
                view->ClipToInverseShape(&s);
        else
                view->ClipToShape(&s);
}


static void
testBase(BView* view, clipper clip, bool inverse)
{
        clip(view, baseRect, inverse);
        view->SetHighColor(255,0,0);
        view->FillRect(bigRect);
}

static void
testBaseDirect(BView* view, clipper clip)
{
        testBase(view, clip, false);
}

static void
testBaseInverse(BView* view, clipper clip)
{
        testBase(view, clip, true);
}

static void
testCross(BView* view, clipper clip, bool inverse)
{
        clip(view, crossRect, inverse);
        view->SetHighColor(0,0,255);
        view->FillRect(bigRect);
}

static void
testCorner(BView* view, clipper clip, bool inverse)
{
        clip(view, corner, inverse);
        view->SetHighColor(0,255,0);
        view->FillRect(bigRect);
}

static void
testCross00(BView* view, clipper clip)
{
        testBase(view, clip, false);
        testCross(view, clip, false);
}

static void
testCross01(BView* view, clipper clip)
{
        testBase(view, clip, false);
        testCross(view, clip, true);
}

static void
testCross10(BView* view, clipper clip)
{
        testBase(view, clip, true);
        testCross(view, clip, false);
}

static void
testCross11(BView* view, clipper clip)
{
        testBase(view, clip, true);
        testCross(view, clip, true);
}

static void
test3000(BView* view, clipper clip)
{
        testBase(view, clip, false);
        testCorner(view, clip, false);
        testCross(view, clip, false);
}

static void
test3001(BView* view, clipper clip)
{
        testBase(view, clip, false);
        testCorner(view, clip, false);
        testCross(view, clip, true);
}

static void
test3010(BView* view, clipper clip)
{
        testBase(view, clip, false);
        testCorner(view, clip, true);
        testCross(view, clip, false);
}

static void
test3011(BView* view, clipper clip)
{
        testBase(view, clip, false);
        testCorner(view, clip, true);
        testCross(view, clip, true);
}

static void
test3100(BView* view, clipper clip)
{
        testBase(view, clip, true);
        testCorner(view, clip, false);
        testCross(view, clip, false);
}

static void
test3101(BView* view, clipper clip)
{
        testBase(view, clip, true);
        testCorner(view, clip, false);
        testCross(view, clip, true);
}

static void
test3110(BView* view, clipper clip)
{
        testBase(view, clip, true);
        testCorner(view, clip, true);
        testCross(view, clip, false);
}

static void
test3111(BView* view, clipper clip)
{
        testBase(view, clip, true);
        testCorner(view, clip, true);
        testCross(view, clip, true);
}

static const test tests[] = {
        testBaseDirect, testBaseInverse,
        testCross00, testCross01, testCross10, testCross11,
        test3000, test3001, test3010, test3011,
        test3100, test3101, test3110, test3111
};


class View : public BView {
public:
                                                                View(const char* name, test, clipper);
                        void                            Draw(BRect);
                        void                            AttachedToWindow();

private:
                        test                            fTest;
                        clipper                         fClipper;
};

View::View(const char* name, test fTest, clipper fClipper)
        :
        BView(BRect(0,0, 100,100), name, 0, B_WILL_DRAW),
        fTest(fTest),
        fClipper(fClipper)
{
}

void
View::AttachedToWindow()
{
        BView::AttachedToWindow();
        TranslateBy(50, 50);
}

void
View::Draw(BRect)
{
        fTest(this, fClipper);
}


class App : public BApplication {
public:
                                                                App();
};

App::App()
        :
        BApplication("application/x-vnd.Haiku-Test_inverse_clip")
{
        BWindow* window = new BWindow(BRect(100,100, 800,400), "clip test",
                B_TITLED_WINDOW, B_QUIT_ON_WINDOW_CLOSE);

        BGridView* grid = new BGridView();
        grid->SetResizingMode(B_FOLLOW_ALL_SIDES);

        BLayoutBuilder::Grid<> layout(grid);
        layout.SetInsets(B_USE_DEFAULT_SPACING);

        int testsCount = B_COUNT_OF(tests);
        for (int i = 0; i < testsCount; i++) {
                layout.Add(new View("region", tests[i], rectClipper), 0, i);
                layout.Add(new View("rotate", tests[i], rectClipper), 1, i);
                        // This one changes from Region to Shape clipping
                layout.Add(new View("picture", tests[i], pictureClipper), 2, i);
                layout.Add(new View("rotate", tests[i], pictureClipper), 3, i);
                layout.Add(new View("shape", tests[i], shapeClipper), 4, i);
                layout.Add(new View("rotate", tests[i], shapeClipper), 5, i);
        }

        BScrollView* scroll = new BScrollView("scroll", grid, B_FOLLOW_ALL_SIDES,
                0, true, true, B_NO_BORDER);
        window->AddChild(scroll);
        BRect bounds(window->Bounds());
        scroll->ResizeTo(bounds.Width(), bounds.Height());

        BView* rotate;
        while ((rotate = window->FindView("rotate")) != NULL) {
                rotate->RotateBy(0.78);
                rotate->SetName("rotated");
        }

        window->Show();
}


int
main()
{
        App app;
        app.Run();
        return 0;
}