/*

        StarWindow.cpp

        by Pierre Raynaud-Richard.

*/

/*
        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 "StarWindow.h"
#include "Stars.h"

#include <string.h>
#include <stdlib.h>

#include <AppFileInfo.h>
#include <FindDirectory.h>
#include <Alert.h>
#include <File.h>
#include <Path.h>

#include <Debug.h>

// return the version_info of a file, described by its
// name and its generic folder (in find_directory syntax).
status_t get_file_version_info( directory_which dir,
                                                                char                    *filename,
                                                                version_info    *info) {
        BPath                   path;
        BFile                   file;
        status_t                res;
        BAppFileInfo    appinfo;

        // find the directory
        if ((res = find_directory(dir, &path)) != B_NO_ERROR)
                return res;

        // find the file
        path.Append(filename);
        file.SetTo(path.Path(), O_RDONLY);
        if ((res = file.InitCheck()) != B_NO_ERROR)
                return res;

        // get the version_info
        if ((res = appinfo.SetTo(&file)) != B_NO_ERROR)
                return res;
        return appinfo.GetVersionInfo(info, B_APP_VERSION_KIND);
}

enum {
        // pseudo-random generator parameters (not very good ones,
        // but good enough for what we do here).
        CRC_START               = 0x56dec231,
        CRC_KEY                 = 0x1789feb3
};


StarWindow::StarWindow(BRect frame, const char *name)
        : BDirectWindow(frame, name, B_TITLED_WINDOW, 0)
{
        uint32                  i;
        int32                   x, y, dx, dy, cnt, square;

        // init the crc pseudo-random generator
        crc_alea = CRC_START;

        // allocate the star struct array
        star_count_max = 8192;
        star_count = 0;
        star_list = (star*)malloc(sizeof(star)*star_count_max);

        // initialise the default state of the star array
        for (i = 0; i < star_count_max; i++) {
                // peek a random vector. This is certainly not the nicest way
                // to do it (the probability and the angle are linked), but that's
                // simple and doesn't require any trigonometry.
                do {
                        dx = (crc_alea&0xffff) - 0x8000;
                        CrcStep();
                        CrcStep();

                        dy = (crc_alea&0xffff) - 0x8000;
                        CrcStep();
                        CrcStep();
                } while ((dx == 0) && (dy == 0));

                // enforce a minimal length by doubling the vector as many times
                // as needed.
                square = dx*dx+dy*dy;
                while (square < 0x08000000) {
                        dx <<= 1;
                        dy <<= 1;
                        square <<= 2;
                }

                // save the starting speed vector.
                star_list[i].dx0 = dx;
                star_list[i].dy0 = dy;

                // simulate the animation to see how many moves are needed to
                // get out by at least 1024 in one direction. That will give us
                // an minimal value for how long we should wait before restarting
                // the animation. It wouldn't work if the window was getting
                // much larger than 2048 pixels in one dimension.
                cnt = 0;
                x = 0;
                y = 0;
                while ((x<0x4000000) && (x>-0x4000000) && (y<0x4000000) && (y>-0x4000000)) {
                        x += dx;
                        y += dy;
                        dx += (dx>>4);
                        dy += (dy>>4);
                        cnt++;
                }

                // add a random compenent [0 to 15] to the minimal count before
                // restart.
                star_list[i].count0 = cnt + ((crc_alea&0xf0000)>>16);
                // make the star initialy invisible and fixed, then spread the
                // value of their restart countdown so that they won't start all
                // at the same time, but progressively
                star_list[i].last_draw = INVALID;
                star_list[i].x = 0x40000000;
                star_list[i].y = 0x40000000;
                star_list[i].dx = 0;
                star_list[i].dy = 0;
                star_list[i].count = (i&255);
        }

        // allocate the semaphore used to synchronise the star animation drawing access.
        drawing_lock = create_sem(0, "star locker");

        // spawn the star animation thread (we have better set the force quit flag to
        // false first).
        kill_my_thread = false;
        my_thread = spawn_thread(StarWindow::StarAnimation, "StarAnimation",
                                                         B_DISPLAY_PRIORITY, (void*)this);
        resume_thread(my_thread);

        // add a view in the background to insure that the content area will
        // be properly erased in black. This erase mechanism is not synchronised
        // with the star animaton, which means that from time to time, some
        // stars will be erreneously erased by the view redraw. But as every
        // single star is erased and redraw every frame, that graphic glitch
        // will last less than a frame, and that just in the area being redraw
        // because of a window resize, move... Which means the glitch won't
        // be noticeable. The other solution for erasing the background would
        // have been to do it on our own (which means some serious region
        // calculation and handling all color_space). Better to use the kit
        // to do it, as it gives us access to hardware acceleration...
        frame.OffsetTo(0.0, 0.0);
        //view = new BView(frame, "", B_FOLLOW_ALL, B_WILL_DRAW);

        // The only think we want from the view mechanism is to
        // erase the background in black. Because of the way the
        // star animation is done, this erasing operation doesn't
        // need to be synchronous with the animation. That the
        // reason why we use both the direct access and the view
        // mechanism to draw in the same area of the StarWindow.
        // Such thing is usualy not recommended as synchronisation
        // is generally an issue (drawing in random order usualy
        // gives remanent incorrect result).
        // set the view color to be black (nicer update).
        //view->SetViewColor(0, 0, 0);
        //AddChild(view);

        // Add a shortcut to switch in and out of fullscreen mode.
        AddShortcut('f', B_COMMAND_KEY, new BMessage('full'));

        // As we said before, the window shouldn't get wider than 2048 in any
        // direction, so those limits will do.
        SetSizeLimits(40.0, 2000.0, 40.0, 2000.0);

        // If the graphic card/graphic driver we use doesn't support directwindow
        // in window mode, then we need to switch to fullscreen immediately, or
        // the user won't see anything, as long as it doesn't used the undocumented
        // shortcut. That would be bad behavior...
        if (!BDirectWindow::SupportsWindowMode()) {
                bool            sSwapped;
                char            *buf;
                BAlert          *quit_alert;

                key_map *map;
                get_key_map(&map, &buf);

                if (map != NULL) {
                        sSwapped = (map->left_control_key == 0x5d)
                                && (map->left_command_key == 0x5c);
                } else
                        sSwapped = false;

                free(map);
                free(buf);
                quit_alert = new BAlert("QuitAlert", sSwapped ?
                                        "This demo runs only in full screen mode.\n"
                                        "While running, press 'Ctrl-Q' to quit.":
                                        "This demo runs only in full screen mode.\n"
                                        "While running, press 'Alt-Q' to quit.",
                                        "Quit", "Start demo", NULL,
                                        B_WIDTH_AS_USUAL, B_WARNING_ALERT);
                if (quit_alert->Go() == 0)
                        ((StarsApp*)be_app)->abort_required = true;
                else
                        SetFullScreen(true);
        }
}


StarWindow::~StarWindow()
{
        // force the drawing_thread to quit. This is the easiest way to deal
        // with potential closing problem. When it's not practical, we
        // recommand to use Hide() and Sync() to force the disconnection of
        // the direct access, and use some other flag to guarantee that your
        // drawing thread won't draw anymore. After that, you can pursue the
        // window destructor and kill your drawing thread...
        kill_my_thread = true;
        delete_sem(drawing_lock);

        status_t result;
        wait_for_thread(my_thread, &result);

        // Free window resources. As they're used by the drawing thread, we
        // need to terminate that thread before freeing them, or we could crash.
        free(star_list);
}


bool
StarWindow::QuitRequested()
{
        be_app->PostMessage(B_QUIT_REQUESTED);
        return true;
}


void
StarWindow::MessageReceived(BMessage *message)
{
        int8 key_code;

        switch (message->what) {
                // Switch between full-screen mode and windowed mode.
                case 'full':
                        SetFullScreen(!IsFullScreen());
                        break;
                case B_KEY_DOWN:
                        if (!IsFullScreen())
                                break;
                        if (message->FindInt8("byte", &key_code) != B_OK)
                                break;
                        if (key_code == B_ESCAPE)
                                PostMessage(B_QUIT_REQUESTED);
                        break;
                default:
                        BDirectWindow::MessageReceived(message);
                        break;
        }
}


void
StarWindow::CrcStep()
{
        // basic crc pseudo-random generator
        crc_alea <<= 1;
        if (crc_alea < 0)
                crc_alea ^= CRC_KEY;
}


void
StarWindow::DirectConnected(direct_buffer_info *info)
{
        // you need to use that mask to read the buffer state.
        switch (info->buffer_state & B_DIRECT_MODE_MASK) {
                // start a direct screen connection.
                case B_DIRECT_START:
                        SwitchContext(info);            // update the direct screen infos.
                        release_sem(drawing_lock);      // unblock the animation thread.
                        break;
                // stop a direct screen connection.
                case B_DIRECT_STOP:
                        acquire_sem(drawing_lock);      // block the animation thread.
                        break;
                // modify the state of a direct screen connection.
                case B_DIRECT_MODIFY:
                        acquire_sem(drawing_lock);      // block the animation thread.
                        SwitchContext(info);            // update the direct screen infos.
                        release_sem(drawing_lock);      // unblock the animation thread.
                        break;

                default:
                        break;
        }
}


// This function update the internal graphic context of the StarWindow
// object to reflect the infos send through the DirectConnected API.
// It also update the state of stars (and erase some of them) to
// insure a clean transition during resize. As this function is called
// in DirectConnected, it's a bad idea to do any heavy drawing (long)
// operation. But as we only update the stars (the background will be
// updated a little later by the view system), it's not a big deal.
void
StarWindow::SwitchContext(direct_buffer_info *info)
{
        star                    *s;
        int32                   x, y, deltax, deltay;
        uint32                  i, j, window_area, cx, cy;
        uint32                  star_count_new;
        clipping_rect   *r;

        // calculate the new star count, depending the size of the window frame.
        // we do that because we want to keep the star count proportionnal to
        // the size of the window, to keep an similar overall star density feeling
        window_area = (info->window_bounds.right-info->window_bounds.left+1)*
                                  (info->window_bounds.bottom-info->window_bounds.top+1);
        // max out beyond 1M pixels.
        if (window_area > (1<<20))
                window_area = (1<<20);
        star_count_new = (star_count_max*(window_area>>10))>>10;
        if (star_count_new > star_count_max)
                star_count_new = star_count_max;

        // set the position of the new center of the window (in case of move or resize)
        cx = (info->window_bounds.right+info->window_bounds.left+1)/2;
        cy = (info->window_bounds.bottom+info->window_bounds.top+1)/2;

        // update to the new clipping region. The local copy is kept relative
        // to the center of the animation (origin of the star coordinate).
        clipping_bound.left = info->clip_bounds.left - cx;
        clipping_bound.right = info->clip_bounds.right - cx;
        clipping_bound.top = info->clip_bounds.top - cy;
        clipping_bound.bottom = info->clip_bounds.bottom - cy;
        // the clipping count is bounded (see comment in header file).
        clipping_list_count = info->clip_list_count;
        if (clipping_list_count > MAX_CLIPPING_RECT_COUNT)
                clipping_list_count = MAX_CLIPPING_RECT_COUNT;
        for (i=0; i<clipping_list_count; i++) {
                clipping_list[i].left = info->clip_list[i].left - cx;
                clipping_list[i].right = info->clip_list[i].right - cx;
                clipping_list[i].top = info->clip_list[i].top - cy;
                clipping_list[i].bottom = info->clip_list[i].bottom - cy;
        }

        // update the new rowbyte
        // NOTE: "row_bytes" is completely misnamed, and was misused too
        row_bytes = info->bytes_per_row / (info->bits_per_pixel / 8);

        // update the screen bases (only one of the 3 will be really used).
        draw_ptr8 = (uint8*)info->bits + info->bytes_per_row
                * info->window_bounds.top + info->window_bounds.left
                * (info->bits_per_pixel / 8);
                // Note: parenthesis around "info->bits_per_pixel / 8"
                // are needed to avoid an overflow when info->window_bounds.left
                // becomes negative.

        draw_ptr16 = (uint16*)draw_ptr8;
        draw_ptr32 = (uint32*)draw_ptr8;

        // cancel the erasing of all stars if the buffer has been reset.
        // Because of a bug in the R3 direct window protocol, B_BUFFER_RESET is not set
        // whew showing a previously hidden window. The second test is a reasonnable
        // way to work around that bug...
        if ((info->buffer_state & B_BUFFER_RESET) ||
                (need_r3_buffer_reset_work_around &&
                 ((info->buffer_state & (B_DIRECT_MODE_MASK|B_BUFFER_MOVED)) == B_DIRECT_START))) {
                s = star_list;
                for (i=0; i<star_count_max; i++) {
                        s->last_draw = INVALID;
                        s++;
                }
        }
        // in the other case, update the stars that will stay visible.
        else {
                // calculate the delta vector due to window resize or move.
                deltax = cx_old - (cx - info->window_bounds.left);
                deltay = cy_old - (cy - info->window_bounds.top);
                // check all the stars previously used.
                s = star_list;
                for (i=0; i<star_count; i++) {
                        // if the star wasn't visible before, then no more question.
                        if (s->last_draw == INVALID)
                                goto not_defined;
                        // convert the old position into the new referential.
                        x = (s->x>>16) + deltax;
                        y = (s->y>>16) + deltay;
                        // check if the old position is still visible in the new clipping
                        if ((x < clipping_bound.left) || (x > clipping_bound.right) ||
                                (y < clipping_bound.top) || (y > clipping_bound.bottom))
                                goto invisible;
                        if (clipping_list_count == 1)
                                goto visible;
                        r = clipping_list;
                        for (j=0; j<clipping_list_count; j++) {
                                if ((x >= r->left) && (x <= r->right) &&
                                        (y >= r->top) && (y <= r->bottom))
                                        goto visible;
                                r++;
                        }
                        goto invisible;

                        // if it's still visible...
                visible:
                        if (i >= star_count_new) {
                                // ...and the star won't be used anylonger, then we erase it.
                                if (pixel_depth == 32)
                                        draw_ptr32[s->last_draw] = 0;
                                else if (pixel_depth == 16)
                                        draw_ptr16[s->last_draw] = 0;
                                else
                                        draw_ptr8[s->last_draw] = 0;
                        }
                        goto not_defined;

                        // if the star just became invisible and it was because the
                        // context was modified and not fully stop, then we need to erase
                        // those stars who just became invisible (or they could leave
                        // artefacts in the drawing area in some cases). This problem is
                        // a side effect of the interaction between a complex resizing
                        // case (using 2 B_DIRECT_MODIFY per step), and the dynamic
                        // star count management we are doing. In most case, you never
                        // have to erase things going out of the clipping region...
                invisible:
                        if ((info->buffer_state & B_DIRECT_MODE_MASK) == B_DIRECT_MODIFY) {
                                if (pixel_depth == 32)
                                        draw_ptr32[s->last_draw] = 0;
                                else if (pixel_depth == 16)
                                        draw_ptr16[s->last_draw] = 0;
                                else
                                        draw_ptr8[s->last_draw] = 0;
                        }
                        // and set its last position as invalid.
                        s->last_draw = INVALID;
                not_defined:
                        s++;
                }

                // initialise all the new star (the ones which weren't used but
                // will be use after that context update) to set their last position
                // as invalid.
                s = star_list+star_count;
                for (i=star_count; i<star_count_new; i++) {
                        s->last_draw = INVALID;
                        s++;
                }
        }

        // update the window origin offset.
        window_offset = row_bytes*(cy-info->window_bounds.top) + (cx-info->window_bounds.left);

        // set the pixel_depth and the pixel data, from the color_space.
        switch (info->pixel_format) {
        case B_RGBA32 :
        case B_RGB32 :
                pixel_depth = 32;
                ((uint8*)&pixel32)[0] = 0x20;
                ((uint8*)&pixel32)[1] = 0xff;
                ((uint8*)&pixel32)[2] = 0x20;
                ((uint8*)&pixel32)[3] = 0xff;
                break;
        case B_RGB16 :
                pixel_depth = 16;
                ((uint8*)&pixel16)[0] = 0xe0;
                ((uint8*)&pixel16)[1] = 0x07;
                break;
        case B_RGB15 :
        case B_RGBA15 :
                pixel_depth = 16;
                ((uint8*)&pixel16)[0] = 0xe0;
                ((uint8*)&pixel16)[1] = 0x03;
                break;
        case B_CMAP8 :
                pixel_depth = 8;
                pixel8 = 52;
                break;
        case B_RGBA32_BIG :
        case B_RGB32_BIG :
                pixel_depth = 32;
                ((uint8*)&pixel32)[3] = 0x20;
                ((uint8*)&pixel32)[2] = 0xff;
                ((uint8*)&pixel32)[1] = 0x20;
                ((uint8*)&pixel32)[0] = 0xff;
                break;
        case B_RGB16_BIG :
                pixel_depth = 16;
                ((uint8*)&pixel16)[1] = 0xe0;
                ((uint8*)&pixel16)[0] = 0x07;
                break;
        case B_RGB15_BIG :
        case B_RGBA15_BIG :
                pixel_depth = 16;
                ((uint8*)&pixel16)[1] = 0xe0;
                ((uint8*)&pixel16)[0] = 0x03;
                break;
        default:        // unsupported color space?
                fprintf(stderr, "ERROR - unsupported color space!\n");
                exit(1);
                break;
        }

        // set the new star count.
        star_count = star_count_new;

        // save a copy of the variables used to calculate the move of the window center
        cx_old = cx - info->window_bounds.left;
        cy_old = cy - info->window_bounds.top;
}


// This is the thread doing the star animation itself. It would be easy to
// adapt to do any other sort of pixel animation.
status_t
StarWindow::StarAnimation(void *data)
{
        star                    *s;
        int32                   x, y;
        uint32                  i, j;
        bigtime_t               time;
        StarWindow              *w;
        clipping_rect   *r;

        // receive a pointer to the StarWindow object.
        w = (StarWindow*)data;

        // loop, frame after frame, until asked to quit.
        while (!w->kill_my_thread) {
                // we want a frame to take at least 16 ms.
                time = system_time()+16000;

                // get the right to do direct screen access.
                while (acquire_sem(w->drawing_lock) == B_INTERRUPTED)
                        ;
                if (w->kill_my_thread)
                        break;

                // go through the array of star, for all currently used star.
                s = w->star_list;
                for (i=0; i<w->star_count; i++) {
                        if (s->count == 0) {
                                // restart the star animation, from a random point close to
                                // the center [-16, +15], both axis.
                                x = s->x = ((w->crc_alea&0x1f00)>>8) - 16;
                                y = s->y = ((w->crc_alea&0x1f0000)>>16) - 16;
                                s->dx = s->dx0;
                                s->dy = s->dy0;
                                // add a small random component to the duration of the star
                                s->count = s->count0 + (w->crc_alea&0x7);
                                w->CrcStep();
                        }
                        else {
                                // just move the star
                                s->count--;
                                x = s->x += s->dx;
                                y = s->y += s->dy;
                                s->dx += (s->dx>>4);
                                s->dy += (s->dy>>4);
                        }
                        // erase the previous position, if necessary
                        if (s->last_draw != INVALID) {
                                if (w->pixel_depth == 32)
                                        w->draw_ptr32[s->last_draw] = 0;
                                else if (w->pixel_depth == 16)
                                        w->draw_ptr16[s->last_draw] = 0;
                                else
                                        w->draw_ptr8[s->last_draw] = 0;
                        }
                        // check if the new position is visible in the current clipping
                        x >>= 16;
                        y >>= 16;
                        if ((x < w->clipping_bound.left) || (x > w->clipping_bound.right) ||
                                (y < w->clipping_bound.top) || (y > w->clipping_bound.bottom))
                                goto invisible;
                        if (w->clipping_list_count == 1) {
                visible:
                                // if it's visible, then draw it.
                                s->last_draw = w->window_offset + w->row_bytes*y + x;
                                if (w->pixel_depth == 32)
                                        w->draw_ptr32[s->last_draw] = w->pixel32;
                                else if (w->pixel_depth == 16)
                                        w->draw_ptr16[s->last_draw] = w->pixel16;
                                else
                                        w->draw_ptr8[s->last_draw] = w->pixel8;
                                goto loop;
                        }
                        // handle complex clipping cases
                        r = w->clipping_list;
                        for (j=0; j<w->clipping_list_count; j++) {
                                if ((x >= r->left) && (x <= r->right) &&
                                        (y >= r->top) && (y <= r->bottom))
                                        goto visible;
                                r++;
                        }
                invisible:
                        // if not visible, register the fact that the star wasn't draw.
                        s->last_draw = INVALID;
                loop:
                        s++;
                }

                // release the direct screen access
                release_sem(w->drawing_lock);

                // snooze for whatever time is left from the initial allocation done
                // at the beginning of the loop.
                time -= system_time();
                if (time > 0)
                        snooze(time);
        }
        return 0;
}