/******************************************************************************* / / File: WindowScreen.h / / Description: Client window class for direct screen access. / / Copyright 1993-98, Be Incorporated, All Rights Reserved. / *******************************************************************************/ #ifndef _WINDOW_SCREEN_H #define _WINDOW_SCREEN_H #include #include #include #include #include #include #include /* private struct */ typedef struct { area_id memory_area; area_id io_area; char addon_path[64+B_FILE_NAME_LENGTH]; } _direct_screen_info_; /* private typedef */ typedef int32 (*_add_on_control_)(uint32,void *); /* Global function, allowing to move the position of the mouse when the GameKit is in control of the screen. */ _IMPEXP_GAME void set_mouse_position(int32 x, int32 y); /********************** WARNING - WARNING - WARNING *********************************** This is the current version of WindowScreen. The main purpose of this object is to establish a direct connexion between application and graphic driver, to increase efficiency and abilities. The graphic driver architecture will overcome serious changes in the next release, consequently this could only be a preview version of the real WindowScreen API. Nevertheless, compatibility will be insure in future releases FOR MOST OF THE API, through the use of a compatibility library (the new game library having a name different from "libgame.so"), or a compatibility class (the new WindowScreen class using a different name). Part of the API for which compatibility will not be insure after the Preview Release are specifically pointed out in the following declarations. ****************************************************************************************/ enum { B_ENABLE_VIEW_DRAWING = 0x0001, B_ENABLE_DEBUGGER = 0x0002 }; class BWindowScreen : public BWindow { public: BWindowScreen(const char *title, uint32 space, status_t *error, bool debug_enable = false); BWindowScreen(const char *title, uint32 space, uint32 attributes, status_t *error); virtual ~BWindowScreen(); virtual void Quit(void); virtual void ScreenConnected(bool active); void Disconnect(); virtual void WindowActivated(bool active); virtual void WorkspaceActivated(int32 ws, bool state); virtual void ScreenChanged(BRect screen_size, color_space depth); virtual void Hide(); virtual void Show(); void SetColorList(rgb_color *list,int32 first_index = 0,int32 last_index = 255); status_t SetSpace(uint32 space); bool CanControlFrameBuffer(); status_t SetFrameBuffer(int32 width, int32 height); status_t MoveDisplayArea(int32 x, int32 y); void *IOBase(); // Not supported anymore. It always returns NULL rgb_color *ColorList(); frame_buffer_info *FrameBufferInfo(); graphics_card_hook CardHookAt(int32 index); graphics_card_info *CardInfo(); /******************************* Debugger API Notice ******************************** Those three calls, and the debug_enable flag in the constructor, have been added to help debugging a WindowScreen application without a cross-developement platform or the use of serial debug output. To use them, you need to : - enable the debug mode by setting the debug_enable flag of the constructor to "true". - register all threads that could be accessing the screen directly at any time. To do that, call RegisterThread after spawning the new thread and before resuming it (you should never draw from the Window thread itself, neither register it). - launch your application from Terminal. The GameKit will first swicth to another workspace before opening the WindowScreen. If you launch from workspace 0 [Alt-F1], it will choose the workspace 1 [Alt-F2]. For any other workspace, it will choose the previous one (for example, for workspace 3 (Alt-F4), it will choose workspace 2 [Alt-F3]). Then : - You can use printf(...) anywhere to display informations that will be logged in the Terminal window. You can go back to the Terminal Window at any time (using the correct Alt-F?? key). Switching workspace will automatically suspend all the thread you registered and save the graphic context. Switching back to the WindowScreen workspace will restore everything and resume your application. - If you need to save and restore more states when your application is suspended and resumed, you can overwrite the ForceSwitchForDebug() method. This function is called with active == true just after suspending your app, and active == false just before resuming it. - You can suspend your application by calling the Debugger() method. This will also switch to the Terminal workspace. Then you can resume by just switchng back to the WindowScreen workspace (using the good Alt-F?? key). It's better not to call Debugger() with the WindowScreen locked. In case of crash : - Use the safety short-cut : All the left modifiers (Ctrl, Shift, Option, Command, Alt or equivalents) of your keyboard and F12. That should send you back to 640x480, and the debugger terminal should be visible (and usable) if any. - Then, you can also switch to your Terminal workspace to check the last printf infos. - After you got (we hope) more information about your (or our :-) bug, quit the debugger window. Then you should be able to change your code and run your application again. In any case, check the Error() function immediately after the WindowScreen constructor. A bad error code will mean that the GameKit is in a inconsistent state, and then you have better to reboot your machine. If you don't wnat to reboot, you can also try to run your application in a different workspace. It's far to be perfect, but we hope it will still help. The Debug API will not be support after the Preview Release (replaced by the debug API in the new WindowScreen class). ***************************************************************************************/ void RegisterThread(thread_id id); virtual void SuspensionHook(bool active); void Suspend(char *label); virtual status_t Perform(perform_code d, void *arg); private: typedef BWindow inherited; virtual void _ReservedWindowScreen1(); virtual void _ReservedWindowScreen2(); virtual void _ReservedWindowScreen3(); virtual void _ReservedWindowScreen4(); BWindowScreen(); BWindowScreen(BWindowScreen &); BWindowScreen &operator=(BWindowScreen &); char addon_state; char space_mode; void *io_buffer; bool direct_enable; bool work_state; bool window_state; bool activate_state; int32 lock_state; int32 screen_index; int32 memory_area, io_area; display_mode *old_space; display_mode *new_space; uint32 space0; sem_id activate_sem; sem_id debug_sem; image_id addon_image; rgb_color colorList[256]; GetAccelerantHook m_gah; graphics_card_info card_info; graphics_card_hook hooks[B_HOOK_COUNT]; _direct_screen_info_ info; frame_buffer_info format_info; char *debug_buffer; bool debug_state; bool debug_first; int32 debug_list_count; int32 debug_workspace; thread_id *debug_list; uint32 _attributes; uint32 mode_count; display_mode *mode_list; engine_token *et; wait_engine_idle m_wei; acquire_engine m_ae; release_engine m_re; fill_rectangle fill_rect; screen_to_screen_blit blit_rect; screen_to_screen_transparent_blit trans_blit_rect; screen_to_screen_scaled_filtered_blit scaled_filtered_blit_rect; uint32 _reserved_[21]; static BRect CalcFrame(int32 index, int32 space, display_mode *dmode); int32 SetFullscreen(int32 enable); status_t InitData(uint32 space, uint32 attributes); status_t SetActiveState(int32 state); status_t SetLockState(int32 state); void GetCardInfo(); void Suspend(); void Resume(); status_t GetModeFromSpace(uint32 space, display_mode *dmode); status_t InitClone(); status_t AssertDisplayMode(display_mode *dmode); }; #endif