diff --git a/src/tests/kits/game/Jamfile b/src/tests/kits/game/Jamfile index c4ffc80842..5dd9e7d4dd 100644 --- a/src/tests/kits/game/Jamfile +++ b/src/tests/kits/game/Jamfile @@ -3,4 +3,5 @@ SubDir OBOS_TOP src tests kits game ; SubInclude OBOS_TOP src tests kits game file_game_sound_test ; SubInclude OBOS_TOP src tests kits game set_mouse_position_test ; SubInclude OBOS_TOP src tests kits game simple_game_sound_test ; +SubInclude OBOS_TOP src tests kits game direct_window_test ; diff --git a/src/tests/kits/game/direct_window_test/Jamfile b/src/tests/kits/game/direct_window_test/Jamfile new file mode 100644 index 0000000000..6b805b09ad --- /dev/null +++ b/src/tests/kits/game/direct_window_test/Jamfile @@ -0,0 +1,7 @@ +SubDir OBOS_TOP src tests kits game direct_window_test ; + +SimpleTest direct_window_test + : Stars.cpp StarWindow.cpp + : game be root +; + diff --git a/src/tests/kits/game/direct_window_test/LICENSE b/src/tests/kits/game/direct_window_test/LICENSE new file mode 100644 index 0000000000..86a4268fa9 --- /dev/null +++ b/src/tests/kits/game/direct_window_test/LICENSE @@ -0,0 +1,31 @@ +---------------------- +Be Sample Code License +---------------------- + +Copyright 1991-1999, Be Incorporated. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions, and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions, and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED +AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/src/tests/kits/game/direct_window_test/StarWindow.cpp b/src/tests/kits/game/direct_window_test/StarWindow.cpp new file mode 100644 index 0000000000..988a468bc3 --- /dev/null +++ b/src/tests/kits/game/direct_window_test/StarWindow.cpp @@ -0,0 +1,592 @@ +/* + + 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 + +#include "StarWindow.h" +#include "Stars.h" + +#include +#include + +#include +#include +#include +#include +#include + +#include + +// 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-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 immediatly, 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); + sSwapped = (map->left_control_key==0x5d) && (map->left_command_key==0x5c); + 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() +{ + long result; + + // 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); + 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; iclip_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 + 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) + row_bytes*info->window_bounds.top + info->window_bounds.left; + draw_ptr16 = ((uint16*)info->bits) + row_bytes*info->window_bounds.top + info->window_bounds.left; + draw_ptr32 = ((uint32*)info->bits) + row_bytes*info->window_bounds.top + info->window_bounds.left; + + // 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; ilast_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; ilast_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= 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; ilast_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. +long 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. + acquire_sem(w->drawing_lock); + if (w->kill_my_thread) break; + + // go through the array of star, for all currently used star. + s = w->star_list; + for (i=0; istar_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; jclipping_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; +} + diff --git a/src/tests/kits/game/direct_window_test/StarWindow.h b/src/tests/kits/game/direct_window_test/StarWindow.h new file mode 100644 index 0000000000..b1f4e8a8f9 --- /dev/null +++ b/src/tests/kits/game/direct_window_test/StarWindow.h @@ -0,0 +1,136 @@ +/* + + StarWindow.h + + 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. +*/ + +#ifndef STAR_WINDOW_H +#define STAR_WINDOW_H + +#include +#include + + +class StarWindow : public BDirectWindow { + +public: + // standard constructor and destrcutor + StarWindow(BRect frame, const char *name); +virtual ~StarWindow(); + + // standard window member +virtual bool QuitRequested(); +virtual void MessageReceived(BMessage *message); + + // this is the hook controling direct screen connection +virtual void DirectConnected(direct_buffer_info *info); + + + +private: + // this function is used to inforce a direct access context + // modification. + void SwitchContext(direct_buffer_info *info); + + // function used to increment the pseudo_random generator +inline void CrcStep(); + + // the drawing thread function. +static long StarAnimation(void *data); + + // struct used to control each star. + typedef struct { + // current position (fixed point 16:16). + int32 x; + int32 y; + // current speed vector (16:16). + int32 dx; + int32 dy; + // starting speed vector, define only at init time (16:16). + int32 dx0; + int32 dy0; + // how many moves left before restarting from the center. + uint16 count; + // minimal moves count between two restarts from the center. + uint16 count0; + // offset from the base of the buffer, in pixel, of the + // last drawn position of the star, or INVALID if not + // drawn. + uint32 last_draw; + } star; + + + enum { + // used for star->last_draw + INVALID = 0xffffffff, + // used for the local copy of the clipping region + MAX_CLIPPING_RECT_COUNT = 64 + }; + + + // flag used to force the drawing thread to quit. + bool kill_my_thread; + // the drawing thread doing the star animation. + thread_id my_thread; + // used to synchronise the star animation drawing. + sem_id drawing_lock; + + + // array used for star animation. + star *star_list; + // count of star currently animated. + uint32 star_count; + // maximal count of star in the array. + uint32 star_count_max; + + + // the pixel drawing can be done in 3 depth : 8, 16 or 32. + int32 pixel_depth; + + // base pointer of the screen, one per pixel_depth + uint8 *draw_ptr8; + uint16 *draw_ptr16; + uint32 *draw_ptr32; + + // pixel data, one per pixel_depth (for the same pixel_depth, + // the value depends of the color and the specific color encoding). + uint8 pixel8; + uint16 pixel16; + uint32 pixel32; + + // offset, in bytes, between two lines of the frame buffer. + uint32 row_bytes; + + // offset, in bytes, between the base of the screen and the base + // of the content area of the window (top left corner). + uint32 window_offset; + + // clipping region, defined as a list of rectangle, including the + // smaller possible bounding box. This application will draw only + // in the 64 first rectangles of the region. Region more complex + // than that won't be completly used. This is a valid approximation + // with the current clipping architecture. If a region more complex + // than that is passed to your application, that just means that + // the user is doing something really, really weird. + clipping_rect clipping_bound; + clipping_rect clipping_list[MAX_CLIPPING_RECT_COUNT]; + uint32 clipping_list_count; + + // used for dynamic resizing. + int32 cx_old, cy_old; + + // pseudo-random generator base + int32 crc_alea; + + // enable/disable a work around needed for R3.0 + bool need_r3_buffer_reset_work_around; +}; + +#endif diff --git a/src/tests/kits/game/direct_window_test/Stars.cpp b/src/tests/kits/game/direct_window_test/Stars.cpp new file mode 100644 index 0000000000..d171e568ea --- /dev/null +++ b/src/tests/kits/game/direct_window_test/Stars.cpp @@ -0,0 +1,44 @@ +/* + + Stars.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. +*/ + +#ifndef STAR_WINDOW_H +#include "StarWindow.h" +#endif +#ifndef STARS_H +#include "Stars.h" +#endif + +#include + +int main(int, char**) +{ + StarsApp *myApplication; + + myApplication = new StarsApp(); + if (!myApplication->abort_required) + myApplication->Run(); + delete(myApplication); + return(0); +} + +StarsApp::StarsApp() : BApplication("application/x-vnd.Be.StarsDemo") +{ + abort_required = false; + aWindow = new StarWindow(BRect(120, 150, 540, 420), "Stars"); + // showing the window will also start the direct connection. If you + // Sync() after the show, the direct connection will be established + // when the Sync() return (as far as any part of the content area of + // the window is visible after the show). + if (!abort_required) + aWindow->Show(); +} diff --git a/src/tests/kits/game/direct_window_test/Stars.h b/src/tests/kits/game/direct_window_test/Stars.h new file mode 100644 index 0000000000..0bc14793bd --- /dev/null +++ b/src/tests/kits/game/direct_window_test/Stars.h @@ -0,0 +1,34 @@ +/* + + Stars.h + + 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. +*/ + +#ifndef STARS_H +#define STARS_H + +#ifndef _APPLICATION_H +#include +#endif +#ifndef STAR_WINDOW_H +#include "StarWindow.h" +#endif + +/* not too much to be said... */ +class StarsApp : public BApplication { +public: + StarsApp(); + + bool abort_required; +private: + StarWindow *aWindow; +}; + +#endif