window.hpp

   1 #ifndef _window__hpp__included__
   2 #define _window__hpp__included__
   3
   4 #include "SDL.h"
   5 #include "render.hpp"
   6 #include <string>
   7 #include <map>
   8 #include <list>
   9 #include <stdexcept>
  10
  11 #define WINSTATE_NORMAL 0
  12 #define WINSTATE_COMMAND 1
  13 #define WINSTATE_MODAL 2
  14 #define WINSTATE_IDENTIFY 3
  15
  16 class window;
  17
  18 /**
  19  * This is a handle to graphics system. Note that creating multiple contexts produces undefined results.
  20  */
  21 class window
  22 {
  23 public:
  24         window() throw() {}
  25
  26 /**
  27  * Initialize the graphics system.
  28  */
  29         static void init();
  30
  31 /**
  32  * Shut down the graphics system.
  33  */
  34         static void quit();
  35
  36 /**
  37  * Adds a messages to mesage queue to be shown.
  38  *
  39  * parameter msg: The messages to add (split by '\n').
  40  * throws std::bad_alloc: Not enough memory.
  41  */
  42         static void message(const std::string& msg) throw(std::bad_alloc);
  43
  44 /**
  45  * Get output stream printing into message queue.
  46  *
  47  * Note that lines printed there should be terminated by '\n'.
  48  *
  49  * returns: The output stream.
  50  * throws std::bad_alloc: Not enough memory.
  51  */
  52         static std::ostream& out() throw(std::bad_alloc);
  53
  54 /**
  55  * Displays a modal message, not returning until the message is acknowledged. Keybindings are not available, but
  56  * should quit be generated somehow, modal message will be closed and command callback triggered.
  57  *
  58  * parameter msg: The message to show.
  59  * parameter confirm: If true, ask for Ok/cancel type input.
  60  * returns: If confirm is true, true if ok was chosen, false if cancel was chosen. Otherwise always false.
  61  * throws std::bad_alloc: Not enough memory.
  62  */
  63         static bool modal_message(const std::string& msg, bool confirm = false) throw(std::bad_alloc);
  64
  65 /**
  66  * Displays fatal error message, quitting after the user acks it.
  67  */
  68         static void fatal_error() throw();
  69
  70 /**
  71  * Bind a key.
  72  *
  73  * parameter mod: Set of modifiers.
  74  * parameter modmask: Modifier mask (set of modifiers).
  75  * parameter keyname: Name of key or pseudo-key.
  76  * parameter command: Command to run.
  77  * throws std::bad_alloc: Not enough memory.
  78  * throws std::runtime_error: Invalid key or modifier name, or conflict.
  79  */
  80         static void bind(std::string mod, std::string modmask, std::string keyname, std::string command)
  81                 throw(std::bad_alloc, std::runtime_error);
  82
  83 /**
  84  * Unbind a key.
  85  *
  86  * parameter mod: Set of modifiers.
  87  * parameter modmask: Modifier mask (set of modifiers).
  88  * parameter keyname: Name of key or pseudo-key.
  89  * throws std::bad_alloc: Not enough memory.
  90  * throws std::runtime_error: Invalid key or modifier name, or not bound.
  91  */
  92         static void unbind(std::string mod, std::string modmask, std::string keyname) throw(std::bad_alloc,
  93                 std::runtime_error);
  94
  95 /**
  96  * Dump bindings into this window.
  97  *
  98  * throws std::bad_alloc: Not enough memory.
  99  */
 100         static void dumpbindings() throw(std::bad_alloc);
 101
 102 /**
 103  * Processes inputs. If in non-modal mode (normal mode without pause), this returns quickly. Otherwise it waits
 104  * for modal mode to exit.
 105  *
 106  * throws std::bad_alloc: Not enough memory.
 107  */
 108         static void poll_inputs() throw(std::bad_alloc);
 109
 110 /**
 111  * Get emulator status area
 112  *
 113  * returns: Emulator status area.
 114  */
 115         static std::map<std::string, std::string>& get_emustatus() throw();
 116
 117 /**
 118  * Notify that the screen has been updated.
 119  *
 120  * parameter full: Do full refresh if true.
 121  */
 122         static void notify_screen_update(bool full = false) throw();
 123
 124 /**
 125  * Set the screen to use as main surface.
 126  *
 127  * parameter scr: The screen to use.
 128  */
 129         static void set_main_surface(screen& scr) throw();
 130
 131 /**
 132  * Enable/Disable pause mode.
 133  *
 134  * parameter enable: Enable pause if true, disable otherwise.
 135  */
 136         static void paused(bool enable) throw();
 137
 138 /**
 139  * Wait specified number of milliseconds (polling for input).
 140  *
 141  * parameter msec: Number of ms to wait.
 142  * throws std::bad_alloc: Not enough memory.
 143  */
 144         static void wait_msec(uint64_t msec) throw(std::bad_alloc);
 145
 146 /**
 147  * Cancel pending wait_msec, making it return now.
 148  */
 149         static void cancel_wait() throw();
 150
 151 /**
 152  * Enable or disable sound.
 153  *
 154  * parameter enable: Enable sounds if true, otherwise disable sounds.
 155  */
 156         static void sound_enable(bool enable) throw();
 157
 158 /**
 159  * Input audio sample (at 32040.5Hz).
 160  *
 161  * parameter left: Left sample.
 162  * parameter right: Right sample.
 163  */
 164         static void play_audio_sample(uint16_t left, uint16_t right) throw();
 165
 166 /**
 167  * Set window main screen compensation parameters. This is used for mouse click reporting.
 168  *
 169  * parameter xoffset: X coordinate of origin.
 170  * parameter yoffset: Y coordinate of origin.
 171  * parameter hscl: Horizontal scaling factor.
 172  * parameter vscl: Vertical scaling factor.
 173  */
 174         static void set_window_compensation(uint32_t xoffset, uint32_t yoffset, uint32_t hscl, uint32_t vscl);
 175 private:
 176         window(const window&);
 177         window& operator==(const window&);
 178 };
 179
 180 /**
 181  * Get number of msec since some undetermined epoch.
 182  *
 183  * returns: The number of milliseconds.
 184  */
 185 uint64_t get_ticks_msec() throw();
 186
 187 #endif