include/core/window.hpp

   1 #ifndef _window__hpp__included__
   2 #define _window__hpp__included__
   3
   4 #include "core/keymapper.hpp"
   5 #include "library/messagebuffer.hpp"
   6 #include "library/emustatus.hpp"
   7 #include "library/framebuffer.hpp"
   8 #include <string>
   9 #include <map>
  10 #include <list>
  11 #include <stdexcept>
  12
  13 class emulator_status;
  14
  15 /**
  16  * Mutex.
  17  */
  18 struct mutex
  19 {
  20 /**
  21  * Hold mutex RAII-style.
  22  */
  23         struct holder
  24         {
  25                 holder(mutex& m) throw();
  26                 ~holder() throw();
  27         private:
  28                 mutex& mut;
  29         };
  30 /**
  31  * Create a mutex. The returned mutex can be deleted using delete.
  32  */
  33         static mutex& aquire() throw(std::bad_alloc);
  34 /**
  35  * Create a recursive mutex. The returned mutex can be deleted using delete.
  36  */
  37         static mutex& aquire_rec() throw(std::bad_alloc);
  38 /**
  39  * Destroy a mutex.
  40  */
  41         virtual ~mutex() throw();
  42 /**
  43  * Lock a mutex.
  44  */
  45         virtual void lock() throw() = 0;
  46 /**
  47  * Lock a mutex.
  48  */
  49         virtual void unlock() throw() = 0;
  50 protected:
  51         mutex() throw();
  52 };
  53
  54 /**
  55  * Condition variable.
  56  */
  57 struct condition
  58 {
  59 /**
  60  * Create a condition variable. The returned condition can be freed using delete.
  61  */
  62         static condition& aquire(mutex& m) throw(std::bad_alloc);
  63 /**
  64  * Destroy a condition.
  65  */
  66         virtual ~condition() throw();
  67 /**
  68  * Return associated mutex.
  69  */
  70         mutex& associated() throw();
  71 /**
  72  * Wait for condition. The associate mutex must be locked.
  73  */
  74         virtual bool wait(uint64_t max_usec) throw() = 0;
  75 /**
  76  * Signal a condition. The associated mutex should be locked.
  77  */
  78         virtual void signal() throw() = 0;
  79 protected:
  80         condition(mutex& m);
  81         mutex& assoc;
  82 };
  83
  84 /**
  85  * Thread ID.
  86  */
  87 struct thread_id
  88 {
  89 /**
  90  * Return thread id for this thread. Can be freed with delete.
  91  */
  92         static thread_id& me() throw(std::bad_alloc);
  93 /**
  94  * Destructor.
  95  */
  96         virtual ~thread_id() throw();
  97 /**
  98  * Is this thread me?
  99  */
 100         virtual bool is_me() throw() = 0;
 101 protected:
 102         thread_id() throw();
 103 };
 104
 105 /**
 106  * Thread.
 107  */
 108 struct thread
 109 {
 110 /**
 111  * Create a thread, jumping to specified starting point.
 112  */
 113         static thread& create(void* (*entrypoint)(void* arg), void* arg) throw(std::bad_alloc, std::runtime_error);
 114 /**
 115  * Destroy a thread, first joining it (if not already joined).
 116  */
 117         virtual ~thread() throw();
 118 /**
 119  * Is this thread still alive?
 120  */
 121         bool is_alive() throw();
 122 /**
 123  * Join a thread.
 124  */
 125         void* join() throw();
 126 protected:
 127         thread() throw();
 128 /**
 129  * Notify that this thread has quit.
 130  */
 131         void notify_quit(void* retval) throw();
 132 /**
 133  * Join a thread.
 134  */
 135         virtual void _join() throw() = 0;
 136 private:
 137         bool alive;
 138         bool joined;
 139         void* returns;
 140 };
 141
 142 /**
 143  * Information about keypress.
 144  */
 145 struct keypress
 146 {
 147 /**
 148  * Create null keypress (no modifiers, NULL key and released).
 149  */
 150         keypress();
 151 /**
 152  * Create new keypress.
 153  */
 154         keypress(keyboard_modifier_set mod, keyboard_key& _key, short _value);
 155 /**
 156  * Create new keypress (two keys).
 157  */
 158         keypress(keyboard_modifier_set mod, keyboard_key& _key, keyboard_key& _key2, short _value);
 159 /**
 160  * Modifier set.
 161  */
 162         keyboard_modifier_set modifiers;
 163 /**
 164  * The actual key (first)
 165  */
 166         keyboard_key* key1;
 167 /**
 168  * The actual key (second)
 169  */
 170         keyboard_key* key2;
 171 /**
 172  * Value for the press
 173  */
 174         short value;
 175 };
 176
 177 /**
 178  * Functions implemented by the graphics plugin.
 179  *
 180  * Unless explicitly noted otherwise, all the methods are to be called from emulation thread if that exists, otherwise
 181  * from the main thread.
 182  */
 183 struct graphics_plugin
 184 {
 185 /**
 186  * Graphics initialization function.
 187  *
 188  * - The first initialization function to be called by platform::init().
 189  */
 190         static void init() throw();
 191 /**
 192  * Graphics quit function.
 193  *
 194  * - The last quit function to be called by platform::quit().
 195  */
 196         static void quit() throw();
 197 /**
 198  * Notification when messages get updated.
 199  */
 200         static void notify_message() throw();
 201 /**
 202  * Notification when status gets updated.
 203  */
 204         static void notify_status() throw();
 205 /**
 206  * Notification when main screen gets updated.
 207  */
 208         static void notify_screen() throw();
 209 /**
 210  * Show modal message dialog.
 211  *
 212  * Parameter text: The text for dialog.
 213  * Parameter confirm: If true, display confirmation dialog, if false, display notification dialog.
 214  * Returns: True if confirmation dialog was confirmed, otherwise false.
 215  */
 216         static bool modal_message(const std::string& text, bool confirm = false) throw();
 217 /**
 218  * Displays fatal error message.
 219  *
 220  * - After this routine returns, the program will quit.
 221  * - The call can occur in any thread.
 222  */
 223         static void fatal_error() throw();
 224 /**
 225  * Identification for graphics plugin.
 226  */
 227         static const char* name;
 228 };
 229
 230 /**
 231  * Functions implemented by the joystick plugin.
 232  *
 233  * Unless explicitly noted otherwise, all the methods are to be called from emulation thread if that exists, otherwise
 234  * from the main thread.
 235  */
 236 struct joystick_plugin
 237 {
 238 /**
 239  * Joystick initialization function.
 240  *
 241  * - The third initialization function to be called by window_init().
 242  * - The call occurs in the main thread.
 243  * - Implemented by the joystick plugin.
 244  */
 245         static void init() throw();
 246 /**
 247  * Joystick quit function.
 248  *
 249  * - The third last quit function to be called by window_quit().
 250  * - The call occurs in the main thread.
 251  * - Implemented by the joystick plugin.
 252  */
 253         static void quit() throw();
 254 /**
 255  * This thread becomes the joystick polling thread.
 256  *
 257  * - Called in joystick polling thread.
 258  */
 259         static void thread_fn() throw();
 260 /**
 261  * Signal the joystick thread to quit.
 262  */
 263         static void signal() throw();
 264 /**
 265  * Identification for joystick plugin.
 266  */
 267         static const char* name;
 268 };
 269
 270 /**
 271  * Platform-specific-related functions.
 272  */
 273 struct platform
 274 {
 275 /**
 276  * Initialize the system.
 277  */
 278         static void init();
 279
 280 /**
 281  * Shut down the system.
 282  */
 283         static void quit();
 284 /**
 285  * Get output stream printing into message queue.
 286  *
 287  * Note that lines printed there should be terminated by '\n'.
 288  *
 289  * Implemented by the generic window code.
 290  *
 291  * returns: The output stream.
 292  * throws std::bad_alloc: Not enough memory.
 293  */
 294         static std::ostream& out() throw(std::bad_alloc);
 295 /**
 296  * Get emulator status area
 297  *
 298  * returns: Emulator status area.
 299  */
 300         static emulator_status& get_emustatus() throw();
 301 /**
 302  * Message buffer.
 303  */
 304         static messagebuffer msgbuf;
 305 /**
 306  * Get message buffer lock.
 307  */
 308         static mutex& msgbuf_lock() throw();
 309 /**
 310  * Set palette used on screen.
 311  */
 312         static void screen_set_palette(unsigned rshift, unsigned gshift, unsigned bshift) throw();
 313 /**
 314  * Adds a messages to mesage queue to be shown.
 315  *
 316  * Implemented by the generic window code.
 317  *
 318  * parameter msg: The messages to add (split by '\n').
 319  * throws std::bad_alloc: Not enough memory.
 320  */
 321         static void message(const std::string& msg) throw(std::bad_alloc);
 322
 323 /**
 324  * Displays fatal error message, quitting after the user acks it (called by fatal_error()).
 325  *
 326  * Needs to be implemented by the graphics plugin.
 327  */
 328         static void fatal_error() throw();
 329 /**
 330  * Enable or disable sound.
 331  *
 332  * Implemented by the generic window code.
 333  *
 334  * parameter enable: Enable sounds if true, otherwise disable sounds.
 335  */
 336         static void sound_enable(bool enable) throw();
 337 /**
 338  * Are sounds enabled?
 339  */
 340         static bool is_sound_enabled() throw();
 341 /**
 342  * Set sound device.
 343  */
 344         static void set_sound_device(const std::string& dev) throw();
 345 /**
 346  * Show modal message dialog.
 347  *
 348  * Parameter text: The text for dialog.
 349  * Parameter confirm: If true, display confirmation dialog, if false, display notification dialog.
 350  * Returns: True, if confirmation dialog was confirmed, otherwise false.
 351  */
 352         static bool modal_message(const std::string& text, bool confirm = false) throw()
 353         {
 354                 return graphics_plugin::modal_message(text, confirm);
 355         }
 356 /**
 357  * Process command and keypress queues.
 358  *
 359  * - If emulating normally, this routine returns fast.
 360  * - If emulator is in pause mode, this routine will block until emulator has left pause mode.
 361  * - If emulator is in some special mode, this routine can block until said mode is left.
 362  */
 363         static void flush_command_queue() throw();
 364 /**
 365  * Enable/Disable pause mode.
 366  *
 367  * - This function doesn't actually block. For actual paused blocking, use flush_command_queue().
 368  *
 369  * Parameter enable: Enable pause mode if true, disable pause mode if false.
 370  */
 371         static void set_paused(bool enable) throw();
 372 /**
 373  * Wait specified number of milliseconds before returning.
 374  *
 375  * - The command and keypresses queues are processed while waiting.
 376  *
 377  * Parameter usec: The number of microseconds to wait.
 378  */
 379         static void wait(uint64_t usec) throw();
 380 /**
 381  * Cause call to wait() to return immediately.
 382  */
 383         static void cancel_wait() throw();
 384 /**
 385  * Notify received message.
 386  */
 387         static void notify_message() throw()
 388         {
 389                 graphics_plugin::notify_message();
 390         }
 391 /**
 392  * Notify changed status.
 393  */
 394         static void notify_status() throw()
 395         {
 396                 graphics_plugin::notify_status();
 397         }
 398 /**
 399  * Notify changed screen.
 400  */
 401         static void notify_screen() throw()
 402         {
 403                 graphics_plugin::notify_screen();
 404         }
 405 /**
 406  * Set modal pause mode.
 407  *
 408  * - Modal pause works like ordinary pause, except it uses a separate flag.
 409  *
 410  * Parameter enable: If true, enable modal pause, else disable it.
 411  */
 412         static void set_modal_pause(bool enable) throw();
 413 /**
 414  * Queue keypress.
 415  *
 416  * - Can be called from any thread.
 417  *
 418  * Parameter k: The keypress to queue.
 419  */
 420         static void queue(const keypress& k) throw(std::bad_alloc);
 421 /**
 422  * Queue command.
 423  *
 424  * - Can be called from any thread.
 425  *
 426  * Parameter c: The command to queue.
 427  */
 428         static void queue(const std::string& c) throw(std::bad_alloc);
 429 /**
 430  * Queue function to be called in emulation thread.
 431  *
 432  * - Can be called from any thread (exception: Synchronous mode can not be used from emulation nor main threads).
 433  *
 434  * Parameter f: The function to execute.
 435  * Parameter arg: Argument to pass to the function.
 436  * Parameter sync: If true, execute function call synchronously, else asynchronously.
 437  */
 438         static void queue(void (*f)(void* arg), void* arg, bool sync) throw(std::bad_alloc);
 439 /**
 440  * Run all queues.
 441  */
 442         static void run_queues() throw();
 443
 444         static bool pausing_allowed;
 445         static double global_volume;
 446         static volatile bool do_exit_dummy_event_loop;
 447         static void dummy_event_loop() throw();
 448         static void exit_dummy_event_loop() throw();
 449 };
 450
 451 class modal_pause_holder
 452 {
 453 public:
 454         modal_pause_holder();
 455         ~modal_pause_holder();
 456 private:
 457         modal_pause_holder(const modal_pause_holder&);
 458         modal_pause_holder& operator=(const modal_pause_holder&);
 459 };
 460
 461 template<typename T>
 462 void functor_call_helper(void* args)
 463 {
 464         (*reinterpret_cast<T*>(args))();
 465 }
 466
 467 template<typename T>
 468 void runemufn(T fn)
 469 {
 470         platform::queue(functor_call_helper<T>, &fn, true);
 471 }
 472
 473 /**
 474  * If set, queueing synchronous function produces a warning.
 475  */
 476 extern volatile bool queue_synchronous_fn_warning;
 477
 478 #endif