include/core/window.hpp

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