include/core/window.hpp

   1 #ifndef _window__hpp__included__
   2 #define _window__hpp__included__
   3
   4 #include "interface/romtype.hpp"
   5 #include "library/keyboard.hpp"
   6 #include "library/messagebuffer.hpp"
   7 #include "library/framebuffer.hpp"
   8 #include <string>
   9 #include <map>
  10 #include <list>
  11 #include <stdexcept>
  12
  13 class rom_request;
  14
  15 //Various methods corresponding to graphics_driver_*
  16 struct _graphics_driver
  17 {
  18         void (*init)();
  19         void (*quit)();
  20         void (*notify_message)();
  21         void (*error_message)(const std::string& text);
  22         void (*fatal_error)();
  23         const char* (*name)();
  24         void (*request_rom)(rom_request& req);
  25 };
  26
  27 struct graphics_driver
  28 {
  29         graphics_driver(_graphics_driver drv);
  30 };
  31
  32 //Is dummy graphics plugin.
  33 bool graphics_driver_is_dummy();
  34 /**
  35  * Graphics initialization function.
  36  *
  37  * - The first initialization function to be called by platform::init().
  38  */
  39 void graphics_driver_init() throw();
  40 /**
  41  * Graphics quit function.
  42  *
  43  * - The last quit function to be called by platform::quit().
  44  */
  45 void graphics_driver_quit() throw();
  46 /**
  47  * Notification when messages get updated.
  48  */
  49 void graphics_driver_notify_message() throw();
  50 /**
  51  * Show error message dialog when UI thread is free.
  52  *
  53  * Parameter text: The text for dialog.
  54  */
  55 void graphics_driver_error_message(const std::string& text) throw();
  56 /**
  57  * Displays fatal error message.
  58  *
  59  * - After this routine returns, the program will quit.
  60  * - The call can occur in any thread.
  61  */
  62 void graphics_driver_fatal_error() throw();
  63 /**
  64  * Identification for graphics plugin.
  65  */
  66 const char* graphics_driver_name();
  67 /**
  68  * Request a ROM image.
  69  */
  70 void graphics_driver_request_rom(rom_request& req);
  71
  72 /**
  73  * Platform-specific-related functions.
  74  */
  75 struct platform
  76 {
  77 /**
  78  * Initialize the system.
  79  */
  80         static void init();
  81
  82 /**
  83  * Shut down the system.
  84  */
  85         static void quit();
  86 /**
  87  * Get output stream printing into message queue.
  88  *
  89  * Note that lines printed there should be terminated by '\n'.
  90  *
  91  * Implemented by the generic window code.
  92  *
  93  * returns: The output stream.
  94  * throws std::bad_alloc: Not enough memory.
  95  */
  96         static std::ostream& out() throw(std::bad_alloc);
  97 /**
  98  * Message buffer.
  99  */
 100         static messagebuffer msgbuf;
 101 /**
 102  * Get message buffer lock.
 103  */
 104         static threads::lock& msgbuf_lock() throw();
 105 /**
 106  * Adds a messages to mesage queue to be shown.
 107  *
 108  * Implemented by the generic window code.
 109  *
 110  * parameter msg: The messages to add (split by '\n').
 111  * throws std::bad_alloc: Not enough memory.
 112  */
 113         static void message(const std::string& msg) throw(std::bad_alloc);
 114 /**
 115  * Displays fatal error message, quitting after the user acks it (called by fatal_error()).
 116  *
 117  * Needs to be implemented by the graphics plugin.
 118  */
 119         static void fatal_error() throw();
 120 /**
 121  * Enable or disable sound.
 122  *
 123  * Implemented by the generic window code.
 124  *
 125  * parameter enable: Enable sounds if true, otherwise disable sounds.
 126  */
 127         static void sound_enable(bool enable) throw();
 128 /**
 129  * Are sounds enabled?
 130  */
 131         static bool is_sound_enabled() throw();
 132 /**
 133  * Set sound device.
 134  */
 135         static void set_sound_device(const std::string& pdev, const std::string& rdev) throw();
 136 /**
 137  * Set sound device by description.
 138  */
 139         static void set_sound_device_by_description(const std::string& pdev, const std::string& rdev) throw();
 140 /**
 141  * Get sound device description.
 142  */
 143         static std::string get_sound_device_description(bool rec) throw(std::bad_alloc);
 144 /**
 145  * Show error message dialog after UI thread becomes free.
 146  *
 147  * Parameter text: The text for dialog.
 148  */
 149         static void error_message(const std::string& text) throw()
 150         {
 151                 return graphics_driver_error_message(text);
 152         }
 153 /**
 154  * Process command and keypress queues.
 155  *
 156  * - If emulating normally, this routine returns fast.
 157  * - If emulator is in pause mode, this routine will block until emulator has left pause mode.
 158  * - If emulator is in some special mode, this routine can block until said mode is left.
 159  */
 160         static void flush_command_queue() throw();
 161 /**
 162  * Enable/Disable pause mode.
 163  *
 164  * - This function doesn't actually block. For actual paused blocking, use flush_command_queue().
 165  *
 166  * Parameter enable: Enable pause mode if true, disable pause mode if false.
 167  */
 168         static void set_paused(bool enable) throw();
 169 /**
 170  * Wait specified number of milliseconds before returning.
 171  *
 172  * - The command and keypresses queues are processed while waiting.
 173  *
 174  * Parameter usec: The number of microseconds to wait.
 175  */
 176         static void wait(uint64_t usec) throw();
 177 /**
 178  * Cause call to wait() to return immediately.
 179  */
 180         static void cancel_wait() throw();
 181 /**
 182  * Notify received message.
 183  */
 184         static void notify_message() throw()
 185         {
 186                 graphics_driver_notify_message();
 187         }
 188 /**
 189  * Set modal pause mode.
 190  *
 191  * - Modal pause works like ordinary pause, except it uses a separate flag.
 192  *
 193  * Parameter enable: If true, enable modal pause, else disable it.
 194  */
 195         static void set_modal_pause(bool enable) throw();
 196 /**
 197  * Run all queues.
 198  */
 199         static void run_queues() throw();
 200
 201         static bool pausing_allowed;
 202         static double global_volume;
 203         static volatile bool do_exit_dummy_event_loop;
 204         static void dummy_event_loop() throw();
 205         static void exit_dummy_event_loop() throw();
 206 };
 207
 208 class modal_pause_holder
 209 {
 210 public:
 211         modal_pause_holder();
 212         ~modal_pause_holder();
 213 private:
 214         modal_pause_holder(const modal_pause_holder&);
 215         modal_pause_holder& operator=(const modal_pause_holder&);
 216 };
 217
 218 /**
 219  * If set, queueing synchronous function produces a warning.
 220  */
 221 extern volatile bool queue_synchronous_fn_warning;
 222
 223 #endif