include/core/window.hpp

   1 #ifndef _window__hpp__included__
   2 #define _window__hpp__included__
   3
   4 #include "core/rom.hpp"
   5 #include "interface/romtype.hpp"
   6 #include "library/keyboard.hpp"
   7 #include "library/messagebuffer.hpp"
   8 #include "library/framebuffer.hpp"
   9 #include <string>
  10 #include <map>
  11 #include <list>
  12 #include <stdexcept>
  13
  14 /**
  15  * Information about keypress.
  16  */
  17 struct keypress
  18 {
  19 /**
  20  * Create null keypress (no modifiers, NULL key and released).
  21  */
  22         keypress();
  23 /**
  24  * Create new keypress.
  25  */
  26         keypress(keyboard::modifier_set mod, keyboard::key& _key, short _value);
  27 /**
  28  * Create new keypress (two keys).
  29  */
  30         keypress(keyboard::modifier_set mod, keyboard::key& _key, keyboard::key& _key2, short _value);
  31 /**
  32  * Modifier set.
  33  */
  34         keyboard::modifier_set modifiers;
  35 /**
  36  * The actual key (first)
  37  */
  38         keyboard::key* key1;
  39 /**
  40  * The actual key (second)
  41  */
  42         keyboard::key* key2;
  43 /**
  44  * Value for the press
  45  */
  46         short value;
  47 };
  48
  49 //ROM request.
  50 struct rom_request
  51 {
  52         //List of core types.
  53         std::vector<core_type*> cores;
  54         //Selected core (default core on call).
  55         bool core_guessed;
  56         size_t selected;
  57         //Filename selected (on entry, filename hint).
  58         bool has_slot[ROM_SLOT_COUNT];
  59         bool guessed[ROM_SLOT_COUNT];
  60         std::string filename[ROM_SLOT_COUNT];
  61         std::string hash[ROM_SLOT_COUNT];
  62         std::string hashxml[ROM_SLOT_COUNT];
  63         //Canceled flag.
  64         bool canceled;
  65 };
  66
  67
  68 //Various methods corresponding to graphics_driver_*
  69 struct _graphics_driver
  70 {
  71         void (*init)();
  72         void (*quit)();
  73         void (*notify_message)();
  74         void (*notify_status)();
  75         void (*notify_screen)();
  76         void (*error_message)(const std::string& text);
  77         void (*fatal_error)();
  78         const char* (*name)();
  79         void (*action_updated)();
  80         void (*request_rom)(rom_request& req);
  81 };
  82
  83 struct graphics_driver
  84 {
  85         graphics_driver(_graphics_driver drv);
  86 };
  87
  88 //Is dummy graphics plugin.
  89 bool graphics_driver_is_dummy();
  90 /**
  91  * Graphics initialization function.
  92  *
  93  * - The first initialization function to be called by platform::init().
  94  */
  95 void graphics_driver_init() throw();
  96 /**
  97  * Graphics quit function.
  98  *
  99  * - The last quit function to be called by platform::quit().
 100  */
 101 void graphics_driver_quit() throw();
 102 /**
 103  * Notification when messages get updated.
 104  */
 105 void graphics_driver_notify_message() throw();
 106 /**
 107  * Notification when status gets updated.
 108  */
 109 void graphics_driver_notify_status() throw();
 110 /**
 111  * Notification when main screen gets updated.
 112  */
 113 void graphics_driver_notify_screen() throw();
 114 /**
 115  * Show error message dialog when UI thread is free.
 116  *
 117  * Parameter text: The text for dialog.
 118  */
 119 void graphics_driver_error_message(const std::string& text) throw();
 120 /**
 121  * Displays fatal error message.
 122  *
 123  * - After this routine returns, the program will quit.
 124  * - The call can occur in any thread.
 125  */
 126 void graphics_driver_fatal_error() throw();
 127 /**
 128  * Identification for graphics plugin.
 129  */
 130 const char* graphics_driver_name();
 131 /**
 132  * Enable/Disable an action.
 133  */
 134 void graphics_driver_action_updated();
 135 /**
 136  * Request a ROM image.
 137  */
 138 void graphics_driver_request_rom(rom_request& req);
 139
 140 /**
 141  * Platform-specific-related functions.
 142  */
 143 struct platform
 144 {
 145 /**
 146  * Initialize the system.
 147  */
 148         static void init();
 149
 150 /**
 151  * Shut down the system.
 152  */
 153         static void quit();
 154 /**
 155  * Get output stream printing into message queue.
 156  *
 157  * Note that lines printed there should be terminated by '\n'.
 158  *
 159  * Implemented by the generic window code.
 160  *
 161  * returns: The output stream.
 162  * throws std::bad_alloc: Not enough memory.
 163  */
 164         static std::ostream& out() throw(std::bad_alloc);
 165 /**
 166  * Message buffer.
 167  */
 168         static messagebuffer msgbuf;
 169 /**
 170  * Get message buffer lock.
 171  */
 172         static threads::lock& msgbuf_lock() throw();
 173 /**
 174  * Adds a messages to mesage queue to be shown.
 175  *
 176  * Implemented by the generic window code.
 177  *
 178  * parameter msg: The messages to add (split by '\n').
 179  * throws std::bad_alloc: Not enough memory.
 180  */
 181         static void message(const std::string& msg) throw(std::bad_alloc);
 182
 183 /**
 184  * Displays fatal error message, quitting after the user acks it (called by fatal_error()).
 185  *
 186  * Needs to be implemented by the graphics plugin.
 187  */
 188         static void fatal_error() throw();
 189 /**
 190  * Enable or disable sound.
 191  *
 192  * Implemented by the generic window code.
 193  *
 194  * parameter enable: Enable sounds if true, otherwise disable sounds.
 195  */
 196         static void sound_enable(bool enable) throw();
 197 /**
 198  * Are sounds enabled?
 199  */
 200         static bool is_sound_enabled() throw();
 201 /**
 202  * Set sound device.
 203  */
 204         static void set_sound_device(const std::string& pdev, const std::string& rdev) throw();
 205 /**
 206  * Show error message dialog after UI thread becomes free.
 207  *
 208  * Parameter text: The text for dialog.
 209  */
 210         static void error_message(const std::string& text) throw()
 211         {
 212                 return graphics_driver_error_message(text);
 213         }
 214 /**
 215  * Process command and keypress queues.
 216  *
 217  * - If emulating normally, this routine returns fast.
 218  * - If emulator is in pause mode, this routine will block until emulator has left pause mode.
 219  * - If emulator is in some special mode, this routine can block until said mode is left.
 220  */
 221         static void flush_command_queue() throw();
 222 /**
 223  * Enable/Disable pause mode.
 224  *
 225  * - This function doesn't actually block. For actual paused blocking, use flush_command_queue().
 226  *
 227  * Parameter enable: Enable pause mode if true, disable pause mode if false.
 228  */
 229         static void set_paused(bool enable) throw();
 230 /**
 231  * Wait specified number of milliseconds before returning.
 232  *
 233  * - The command and keypresses queues are processed while waiting.
 234  *
 235  * Parameter usec: The number of microseconds to wait.
 236  */
 237         static void wait(uint64_t usec) throw();
 238 /**
 239  * Cause call to wait() to return immediately.
 240  */
 241         static void cancel_wait() throw();
 242 /**
 243  * Notify received message.
 244  */
 245         static void notify_message() throw()
 246         {
 247                 graphics_driver_notify_message();
 248         }
 249 /**
 250  * Notify changed status.
 251  */
 252         static void notify_status() throw()
 253         {
 254                 graphics_driver_notify_status();
 255         }
 256 /**
 257  * Notify changed screen.
 258  */
 259         static void notify_screen() throw()
 260         {
 261                 graphics_driver_notify_screen();
 262         }
 263 /**
 264  * Set modal pause mode.
 265  *
 266  * - Modal pause works like ordinary pause, except it uses a separate flag.
 267  *
 268  * Parameter enable: If true, enable modal pause, else disable it.
 269  */
 270         static void set_modal_pause(bool enable) throw();
 271 /**
 272  * Queue keypress.
 273  *
 274  * - Can be called from any thread.
 275  *
 276  * Parameter k: The keypress to queue.
 277  */
 278         static void queue(const keypress& k) throw(std::bad_alloc);
 279 /**
 280  * Queue command.
 281  *
 282  * - Can be called from any thread.
 283  *
 284  * Parameter c: The command to queue.
 285  */
 286         static void queue(const std::string& c) throw(std::bad_alloc);
 287 /**
 288  * Queue function to be called in emulation thread.
 289  *
 290  * - Can be called from any thread (exception: Synchronous mode can not be used from emulation nor main threads).
 291  *
 292  * Parameter f: The function to execute.
 293  * Parameter arg: Argument to pass to the function.
 294  * Parameter sync: If true, execute function call synchronously, else asynchronously.
 295  */
 296         static void queue(void (*f)(void* arg), void* arg, bool sync) throw(std::bad_alloc);
 297 /**
 298  * Run all queues.
 299  */
 300         static void run_queues() throw();
 301 /**
 302  * Set availablinty of system thread.
 303  */
 304         static void system_thread_available(bool av) throw();
 305
 306         static bool pausing_allowed;
 307         static double global_volume;
 308         static volatile bool do_exit_dummy_event_loop;
 309         static void dummy_event_loop() throw();
 310         static void exit_dummy_event_loop() throw();
 311 };
 312
 313 class modal_pause_holder
 314 {
 315 public:
 316         modal_pause_holder();
 317         ~modal_pause_holder();
 318 private:
 319         modal_pause_holder(const modal_pause_holder&);
 320         modal_pause_holder& operator=(const modal_pause_holder&);
 321 };
 322
 323 template<typename T>
 324 void functor_call_helper(void* args)
 325 {
 326         (*reinterpret_cast<T*>(args))();
 327 }
 328
 329 template<typename T>
 330 void runemufn(T fn)
 331 {
 332         platform::queue(functor_call_helper<T>, &fn, true);
 333 }
 334
 335 /**
 336  * If set, queueing synchronous function produces a warning.
 337  */
 338 extern volatile bool queue_synchronous_fn_warning;
 339
 340 #endif