/*
        Copyright 1999, Be Incorporated.   All Rights Reserved.
        This file may be used under the terms of the Be Sample Code License.
*/

#include <Application.h>
#include <WindowScreen.h>
#include <Screen.h>
#include <string.h>

typedef long (*blit_hook)(long,long,long,long,long,long);
typedef long (*sync_hook)();

class NApplication:public BApplication {
public:
        NApplication();
        bool is_quitting; // So that the WindowScreen knows what
                     //       to do when disconnected.
private:
        bool QuitRequested();
        void ReadyToRun();
};

class NWindowScreen:public BWindowScreen {
public:
        NWindowScreen(status_t*);
private:
        void ScreenConnected(bool);
        int32 DrawingCode();
        
        static int32 Entry(void*);

        thread_id fThreadId;
        sem_id fSem;
        area_id fArea;
        uint8* fSaveBuffer;
        uint8* fFrameBuffer;
        ulong fLineLength;
        bool fThreadIsLocked;   // small hack to allow to quit the
                                // app from ScreenConnected()
        blit_hook fBlitHook; // hooks to the graphics driver functions
        sync_hook fSyncHook;
};


int
main()
{
        NApplication app;
}


NApplication::NApplication()
      :BApplication("application/x-vnd.Be-sample-jbq1")
{
        Run(); // see you in ReadyToRun()
}


void
NApplication::ReadyToRun()
{
        status_t ret = B_ERROR;
        is_quitting = false;
        NWindowScreen* windowScreen = new NWindowScreen(&ret);
        // exit if constructing the WindowScreen failed.
        if (windowScreen == NULL || ret < B_OK)
                PostMessage(B_QUIT_REQUESTED);
}


bool
NApplication::QuitRequested()
{
        is_quitting = true;
        return true;
}


NWindowScreen::NWindowScreen(status_t* ret)
        :
        BWindowScreen("Example", B_8_BIT_640x480, ret),
        fThreadId(-1),
        fSem(-1),
        fArea(-1),
        fSaveBuffer(NULL),
        fFrameBuffer(NULL),
        fLineLength(0),
        fThreadIsLocked(true),
        fBlitHook(NULL),
        fSyncHook(NULL) 
{
        if (*ret < B_OK)
                return;

        // this semaphore controls the access to the WindowScreen
        fSem = create_sem(0, "WindowScreen Access");
        if (fSem < B_OK) {
                *ret = fSem;
                return;
        }

        // this area is used to save the whole framebuffer when
        //       switching workspaces. (better than malloc()).
        fArea = create_area("save", (void**)&fSaveBuffer, B_ANY_ADDRESS,
                                640 * 2048, B_NO_LOCK, B_READ_AREA|B_WRITE_AREA);
        if (fArea < B_OK) {
                *ret = fArea;
                delete_sem(fSem);
                fSem = -1;
                return;
        }
        
        Show(); // let's go. See you in ScreenConnected.
}


void
NWindowScreen::ScreenConnected(bool connected)
{
        if (connected) {
                if (SetSpace(B_8_BIT_640x480) < B_OK || SetFrameBuffer(640, 2048) < B_OK) {
                        // properly set the framebuffer. exit if an error occurs.
                        be_app->PostMessage(B_QUIT_REQUESTED);
                        return;
                }

                // get the hardware acceleration hooks. get them each time
                // the WindowScreen is connected, because of multiple
                // monitor support
                fBlitHook = (blit_hook)CardHookAt(7);
                fSyncHook = (sync_hook)CardHookAt(10);
                
                // cannot work with no hardware blitting
                if (fBlitHook == NULL) {
                        be_app->PostMessage(B_QUIT_REQUESTED);
                        return;
                }
                // get the framebuffer-related info, each time the
                // WindowScreen is connected (multiple monitor)
                fFrameBuffer = (uint8 *)(CardInfo()->frame_buffer);
                fLineLength = FrameBufferInfo()->bytes_per_row;
                if (fThreadId == 0) {
                        // clean the framebuffer
                        memset(fFrameBuffer, 0, 2048 * fLineLength);
                        // spawn the rendering thread. exit if an error occurs.
                        fThreadId = spawn_thread(Entry, "rendering thread", B_URGENT_DISPLAY_PRIORITY, this);
                        if (fThreadId < B_OK || resume_thread(fThreadId) < B_OK)
                                be_app->PostMessage(B_QUIT_REQUESTED);
                } else {
                        for (int y = 0; y < 2048; y++) {
                                // restore the framebuffer when switching back from
                                // another workspace.
                                memcpy(fFrameBuffer + y * fLineLength, fSaveBuffer + 640 * y, 640);
                        }
                }
                
                // set our color list.
                rgb_color palette[256];
                for (int i = 0; i < 128; i++) {
                        rgb_color c1 = {i * 2, i * 2, i * 2};
                        rgb_color c2 = {127 + i, 2 * i, 254};
                        palette[i] = c1;
                        palette[i + 128] = c2;
                }
                SetColorList(palette);
                // allow the rendering thread to run.
                fThreadIsLocked = false;
                release_sem(fSem);
        } else {
                // block the rendering thread.
                if (!fThreadIsLocked) {
                        acquire_sem(fSem);
                        fThreadIsLocked = true;
                }

                // kill the rendering and clean up when quitting
                if ((((NApplication*)be_app)->is_quitting)) {
                        status_t ret;
                        kill_thread(fThreadId);
                        wait_for_thread(fThreadId, &ret);
                        delete_sem(fSem);
                        delete_area(fArea);
                } else {
                        // set the color list black so that the screen doesn't seem
                        // to freeze while saving the framebuffer
                        rgb_color c = { 0, 0, 0 };
                        rgb_color palette[256];
                        for (int i = 0; i < 256; i++)
                                palette[i] = c;
                        SetColorList(palette);
                        
                        // save the framebuffer
                        for (int y = 0; y < 2048; y++)
                                memcpy(fSaveBuffer + 640 * y, fFrameBuffer + y * fLineLength, 640);
                }
        }
}


int32
NWindowScreen::Entry(void* castToThis)
{
        return ((NWindowScreen *)castToThis)->DrawingCode();
}


int32
NWindowScreen::DrawingCode()
{
        // gain access to the framebuffer before writing to it.

        acquire_sem(fSem);

        for (int j = 1440; j < 2048; j++) {
                for (int i; i < 640; i++) {
                        // draw the backgroud ripple pattern
                        float val=63.99*(1+cos(2*M_PI*((i-320)*(i-320)+(j-1744)*(j-1744))/1216));
                        fFrameBuffer[i + fLineLength*j]=int(val);
                }
        }

        ulong numframe = 0;
        bigtime_t trgt = 0;
        ulong y_origin;
        uint8* current_frame;
        while (true) {
                // the framebuffer coordinates of the next frame
                y_origin = 480 * (numframe % 3);
                // and a pointer to it
                current_frame = fFrameBuffer + y_origin * fLineLength;
                // copy the background
                int ytop = numframe % 608, ybot = ytop + 479;
                if (ybot < 608) {
                        fBlitHook(0,1440+ytop,0,y_origin,639,479);
                } else {
                        fBlitHook(0,1440+ytop,0,y_origin,639,1086-ybot);
                        fBlitHook(0,1440,0,y_origin+1087-ybot,639,ybot-608);
                }
                // calculate the circle position. doing such calculations
                // between blit() and sync() is a good idea.
                uint32 x=(uint32)(287.99*(1+sin(numframe/72.)));
                uint32 y=(uint32)(207.99*(1+sin(numframe/52.)));
                if (fSyncHook)
                        fSyncHook();
                // draw the circle
                for (int j = 0; j < 64; j++) {
                        for (int i = 0; i < 64; i++) {
                                if ((i-31)*(i-32)+(j-31)*(j-32)<=1024)
                                        current_frame[x + i + fLineLength * (y + j)] += 128;
                        }
                }
                // release the semaphore while waiting. gotta release it
                // at some point or nasty things will happen!
                release_sem(fSem);
                // try to sync with the vertical retrace
                if (BScreen(this).WaitForRetrace() != B_OK) {
                        // we're doing some triple buffering. unwanted things would
                        // happen if we rendered more pictures than the card can
                        // display. we here make sure not to render more than 55.5 
                        // pictures per second if the card does not support retrace
                        // syncing
                        if (system_time() < trgt)
                                snooze(trgt - system_time());
                        trgt = system_time() + 18000;
                }
                // acquire the semaphore back before talking to the driver
                acquire_sem(fSem);
                // do the page-flipping
                MoveDisplayArea(0, y_origin);
                // and go to the next frame!
                numframe++;
        }
        return 0;
}