The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 1 | #ifndef CONSOLE_H |
| 2 | #define CONSOLE_H |
| 3 | |
| 4 | #include "qemu-char.h" |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 5 | #include "qdict.h" |
| 6 | #include "notify.h" |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 7 | |
| 8 | /* keyboard/mouse support */ |
| 9 | |
| 10 | #define MOUSE_EVENT_LBUTTON 0x01 |
| 11 | #define MOUSE_EVENT_RBUTTON 0x02 |
| 12 | #define MOUSE_EVENT_MBUTTON 0x04 |
| 13 | |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 14 | /* identical to the ps/2 keyboard bits */ |
| 15 | #define QEMU_SCROLL_LOCK_LED (1 << 0) |
| 16 | #define QEMU_NUM_LOCK_LED (1 << 1) |
| 17 | #define QEMU_CAPS_LOCK_LED (1 << 2) |
| 18 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 19 | /* in ms */ |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 20 | #ifdef CONFIG_ANDROID |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 21 | #define GUI_REFRESH_INTERVAL (1000/60) /* 60 frames/s is better */ |
| 22 | #else |
| 23 | #define GUI_REFRESH_INTERVAL 30 |
| 24 | #endif |
| 25 | |
| 26 | typedef void QEMUPutKBDEvent(void *opaque, int keycode); |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 27 | typedef void QEMUPutLEDEvent(void *opaque, int ledstate); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 28 | typedef void QEMUPutMouseEvent(void *opaque, int dx, int dy, int dz, int buttons_state); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 29 | |
| 30 | typedef struct QEMUPutMouseEntry { |
| 31 | QEMUPutMouseEvent *qemu_put_mouse_event; |
| 32 | void *qemu_put_mouse_event_opaque; |
| 33 | int qemu_put_mouse_event_absolute; |
| 34 | char *qemu_put_mouse_event_name; |
| 35 | |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 36 | int index; |
| 37 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 38 | /* used internally by qemu for handling mice */ |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 39 | QTAILQ_ENTRY(QEMUPutMouseEntry) node; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 40 | } QEMUPutMouseEntry; |
| 41 | |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 42 | typedef struct QEMUPutLEDEntry { |
| 43 | QEMUPutLEDEvent *put_led; |
| 44 | void *opaque; |
| 45 | QTAILQ_ENTRY(QEMUPutLEDEntry) next; |
| 46 | } QEMUPutLEDEntry; |
| 47 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 48 | void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque); |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 49 | void qemu_remove_kbd_event_handler(void); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 50 | QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, |
| 51 | void *opaque, int absolute, |
| 52 | const char *name); |
| 53 | void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry); |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 54 | void qemu_activate_mouse_event_handler(QEMUPutMouseEntry *entry); |
| 55 | |
| 56 | QEMUPutLEDEntry *qemu_add_led_event_handler(QEMUPutLEDEvent *func, void *opaque); |
| 57 | void qemu_remove_led_event_handler(QEMUPutLEDEntry *entry); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 58 | |
| 59 | void kbd_put_keycode(int keycode); |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 60 | void kbd_put_ledstate(int ledstate); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 61 | void kbd_mouse_event(int dx, int dy, int dz, int buttons_state); |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 62 | |
| 63 | /* Does the current mouse generate absolute events */ |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 64 | int kbd_mouse_is_absolute(void); |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 65 | void qemu_add_mouse_mode_change_notifier(Notifier *notify); |
| 66 | void qemu_remove_mouse_mode_change_notifier(Notifier *notify); |
| 67 | |
| 68 | /* Of all the mice, is there one that generates absolute events */ |
| 69 | int kbd_mouse_has_absolute(void); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 70 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 71 | struct MouseTransformInfo { |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 72 | /* Touchscreen resolution */ |
| 73 | int x; |
| 74 | int y; |
| 75 | /* Calibration values as used/generated by tslib */ |
| 76 | int a[7]; |
| 77 | }; |
| 78 | |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 79 | void do_info_mice_print(Monitor *mon, const QObject *data); |
| 80 | void do_info_mice(Monitor *mon, QObject **ret_data); |
| 81 | void do_mouse_set(Monitor *mon, const QDict *qdict); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 82 | |
| 83 | /* keysym is a unicode code except for special keys (see QEMU_KEY_xxx |
| 84 | constants) */ |
| 85 | #define QEMU_KEY_ESC1(c) ((c) | 0xe100) |
| 86 | #define QEMU_KEY_BACKSPACE 0x007f |
| 87 | #define QEMU_KEY_UP QEMU_KEY_ESC1('A') |
| 88 | #define QEMU_KEY_DOWN QEMU_KEY_ESC1('B') |
| 89 | #define QEMU_KEY_RIGHT QEMU_KEY_ESC1('C') |
| 90 | #define QEMU_KEY_LEFT QEMU_KEY_ESC1('D') |
| 91 | #define QEMU_KEY_HOME QEMU_KEY_ESC1(1) |
| 92 | #define QEMU_KEY_END QEMU_KEY_ESC1(4) |
| 93 | #define QEMU_KEY_PAGEUP QEMU_KEY_ESC1(5) |
| 94 | #define QEMU_KEY_PAGEDOWN QEMU_KEY_ESC1(6) |
| 95 | #define QEMU_KEY_DELETE QEMU_KEY_ESC1(3) |
| 96 | |
| 97 | #define QEMU_KEY_CTRL_UP 0xe400 |
| 98 | #define QEMU_KEY_CTRL_DOWN 0xe401 |
| 99 | #define QEMU_KEY_CTRL_LEFT 0xe402 |
| 100 | #define QEMU_KEY_CTRL_RIGHT 0xe403 |
| 101 | #define QEMU_KEY_CTRL_HOME 0xe404 |
| 102 | #define QEMU_KEY_CTRL_END 0xe405 |
| 103 | #define QEMU_KEY_CTRL_PAGEUP 0xe406 |
| 104 | #define QEMU_KEY_CTRL_PAGEDOWN 0xe407 |
| 105 | |
| 106 | void kbd_put_keysym(int keysym); |
| 107 | |
| 108 | /* consoles */ |
| 109 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 110 | #define QEMU_BIG_ENDIAN_FLAG 0x01 |
| 111 | #define QEMU_ALLOCATED_FLAG 0x02 |
David 'Digit' Turner | dd9cb79 | 2010-05-10 23:52:07 -0700 | [diff] [blame] | 112 | #define QEMU_REALPIXELS_FLAG 0x04 |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 113 | |
| 114 | struct PixelFormat { |
| 115 | uint8_t bits_per_pixel; |
| 116 | uint8_t bytes_per_pixel; |
| 117 | uint8_t depth; /* color depth in bits */ |
| 118 | uint32_t rmask, gmask, bmask, amask; |
| 119 | uint8_t rshift, gshift, bshift, ashift; |
| 120 | uint8_t rmax, gmax, bmax, amax; |
| 121 | uint8_t rbits, gbits, bbits, abits; |
| 122 | }; |
| 123 | |
| 124 | struct DisplaySurface { |
| 125 | uint8_t flags; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 126 | int width; |
| 127 | int height; |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 128 | int linesize; /* bytes per line */ |
| 129 | uint8_t *data; |
| 130 | |
| 131 | struct PixelFormat pf; |
| 132 | }; |
| 133 | |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 134 | /* cursor data format is 32bit RGBA */ |
| 135 | typedef struct QEMUCursor { |
| 136 | int width, height; |
| 137 | int hot_x, hot_y; |
| 138 | int refcount; |
| 139 | uint32_t data[]; |
| 140 | } QEMUCursor; |
| 141 | |
| 142 | QEMUCursor *cursor_alloc(int width, int height); |
| 143 | void cursor_get(QEMUCursor *c); |
| 144 | void cursor_put(QEMUCursor *c); |
| 145 | QEMUCursor *cursor_builtin_hidden(void); |
| 146 | QEMUCursor *cursor_builtin_left_ptr(void); |
| 147 | void cursor_print_ascii_art(QEMUCursor *c, const char *prefix); |
| 148 | int cursor_get_mono_bpl(QEMUCursor *c); |
| 149 | void cursor_set_mono(QEMUCursor *c, |
| 150 | uint32_t foreground, uint32_t background, uint8_t *image, |
| 151 | int transparent, uint8_t *mask); |
| 152 | void cursor_get_mono_image(QEMUCursor *c, int foreground, uint8_t *mask); |
| 153 | void cursor_get_mono_mask(QEMUCursor *c, int transparent, uint8_t *mask); |
| 154 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 155 | struct DisplayChangeListener { |
| 156 | int idle; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 157 | uint64_t gui_timer_interval; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 158 | |
| 159 | void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 160 | void (*dpy_resize)(struct DisplayState *s); |
| 161 | void (*dpy_setdata)(struct DisplayState *s); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 162 | void (*dpy_refresh)(struct DisplayState *s); |
| 163 | void (*dpy_copy)(struct DisplayState *s, int src_x, int src_y, |
| 164 | int dst_x, int dst_y, int w, int h); |
| 165 | void (*dpy_fill)(struct DisplayState *s, int x, int y, |
| 166 | int w, int h, uint32_t c); |
| 167 | void (*dpy_text_cursor)(struct DisplayState *s, int x, int y); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 168 | |
| 169 | struct DisplayChangeListener *next; |
| 170 | }; |
| 171 | |
David 'Digit' Turner | 7a5ee57 | 2011-02-02 15:58:45 +0100 | [diff] [blame] | 172 | #ifdef CONFIG_ANDROID |
| 173 | /* The problem with DisplayChangeListener is that the callbacks can't |
| 174 | * differentiate between different DisplayChangeListeners. Instead of |
| 175 | * modifying the type above, which is going to generate conflicts with |
| 176 | * upstream changes, we define our own listener type here. |
| 177 | */ |
| 178 | typedef struct DisplayUpdateListener { |
| 179 | void* opaque; |
| 180 | void (*dpy_update)(void* opaque, int x, int y, int w, int h); |
| 181 | struct DisplayUpdateListener *next; |
| 182 | } DisplayUpdateListener; |
| 183 | #endif |
| 184 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 185 | struct DisplayAllocator { |
| 186 | DisplaySurface* (*create_displaysurface)(int width, int height); |
| 187 | DisplaySurface* (*resize_displaysurface)(DisplaySurface *surface, int width, int height); |
| 188 | void (*free_displaysurface)(DisplaySurface *surface); |
| 189 | }; |
| 190 | |
| 191 | struct DisplayState { |
| 192 | struct DisplaySurface *surface; |
| 193 | void *opaque; |
| 194 | struct QEMUTimer *gui_timer; |
| 195 | |
| 196 | struct DisplayAllocator* allocator; |
| 197 | struct DisplayChangeListener* listeners; |
David 'Digit' Turner | 7a5ee57 | 2011-02-02 15:58:45 +0100 | [diff] [blame] | 198 | #ifdef CONFIG_ANDROID |
| 199 | struct DisplayUpdateListener* update_listeners; |
| 200 | #endif |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 201 | void (*mouse_set)(int x, int y, int on); |
David Turner | f52506f | 2010-09-10 16:11:22 +0200 | [diff] [blame] | 202 | void (*cursor_define)(QEMUCursor *cursor); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 203 | |
| 204 | struct DisplayState *next; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 205 | }; |
| 206 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 207 | void register_displaystate(DisplayState *ds); |
| 208 | DisplayState *get_displaystate(void); |
| 209 | DisplaySurface* qemu_create_displaysurface_from(int width, int height, int bpp, |
| 210 | int linesize, uint8_t *data); |
| 211 | PixelFormat qemu_different_endianness_pixelformat(int bpp); |
| 212 | PixelFormat qemu_default_pixelformat(int bpp); |
| 213 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 214 | DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 215 | |
| 216 | static inline DisplaySurface* qemu_create_displaysurface(DisplayState *ds, int width, int height) |
| 217 | { |
David 'Digit' Turner | 94702b0 | 2011-01-20 02:46:33 +0100 | [diff] [blame] | 218 | return ds->allocator->create_displaysurface(width, height); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | static inline DisplaySurface* qemu_resize_displaysurface(DisplayState *ds, int width, int height) |
| 222 | { |
| 223 | return ds->allocator->resize_displaysurface(ds->surface, width, height); |
| 224 | } |
| 225 | |
| 226 | static inline void qemu_free_displaysurface(DisplayState *ds) |
| 227 | { |
| 228 | ds->allocator->free_displaysurface(ds->surface); |
| 229 | } |
| 230 | |
| 231 | static inline int is_surface_bgr(DisplaySurface *surface) |
| 232 | { |
| 233 | if (surface->pf.bits_per_pixel == 32 && surface->pf.rshift == 0) |
| 234 | return 1; |
| 235 | else |
| 236 | return 0; |
| 237 | } |
| 238 | |
| 239 | static inline int is_buffer_shared(DisplaySurface *surface) |
| 240 | { |
David Turner | f52506f | 2010-09-10 16:11:22 +0200 | [diff] [blame] | 241 | return (!(surface->flags & QEMU_ALLOCATED_FLAG) && |
| 242 | !(surface->flags & QEMU_REALPIXELS_FLAG)); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 243 | } |
| 244 | |
| 245 | static inline void register_displaychangelistener(DisplayState *ds, DisplayChangeListener *dcl) |
| 246 | { |
| 247 | dcl->next = ds->listeners; |
| 248 | ds->listeners = dcl; |
| 249 | } |
| 250 | |
David 'Digit' Turner | 7a5ee57 | 2011-02-02 15:58:45 +0100 | [diff] [blame] | 251 | #ifdef CONFIG_ANDROID |
| 252 | static inline void register_displayupdatelistener(DisplayState *ds, DisplayUpdateListener *dul) |
| 253 | { |
| 254 | dul->next = ds->update_listeners; |
| 255 | ds->update_listeners = dul; |
| 256 | } |
| 257 | |
| 258 | void unregister_displayupdatelistener(DisplayState *ds, DisplayUpdateListener *dul); |
| 259 | |
| 260 | #endif |
| 261 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 262 | static inline void dpy_update(DisplayState *s, int x, int y, int w, int h) |
| 263 | { |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 264 | struct DisplayChangeListener *dcl = s->listeners; |
| 265 | while (dcl != NULL) { |
| 266 | dcl->dpy_update(s, x, y, w, h); |
| 267 | dcl = dcl->next; |
| 268 | } |
David 'Digit' Turner | 7a5ee57 | 2011-02-02 15:58:45 +0100 | [diff] [blame] | 269 | #ifdef CONFIG_ANDROID |
| 270 | DisplayUpdateListener* dul = s->update_listeners; |
| 271 | while (dul != NULL) { |
| 272 | dul->dpy_update(dul->opaque, x, y, w, h); |
| 273 | dul = dul->next; |
| 274 | } |
| 275 | #endif |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 276 | } |
| 277 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 278 | static inline void dpy_resize(DisplayState *s) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 279 | { |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 280 | struct DisplayChangeListener *dcl = s->listeners; |
| 281 | while (dcl != NULL) { |
| 282 | dcl->dpy_resize(s); |
| 283 | dcl = dcl->next; |
| 284 | } |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 285 | } |
| 286 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 287 | static inline void dpy_setdata(DisplayState *s) |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 288 | { |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 289 | struct DisplayChangeListener *dcl = s->listeners; |
| 290 | while (dcl != NULL) { |
| 291 | if (dcl->dpy_setdata) dcl->dpy_setdata(s); |
| 292 | dcl = dcl->next; |
| 293 | } |
| 294 | } |
| 295 | |
| 296 | static inline void dpy_refresh(DisplayState *s) |
| 297 | { |
| 298 | struct DisplayChangeListener *dcl = s->listeners; |
| 299 | while (dcl != NULL) { |
| 300 | if (dcl->dpy_refresh) dcl->dpy_refresh(s); |
| 301 | dcl = dcl->next; |
| 302 | } |
| 303 | } |
| 304 | |
| 305 | static inline void dpy_copy(struct DisplayState *s, int src_x, int src_y, |
| 306 | int dst_x, int dst_y, int w, int h) { |
| 307 | struct DisplayChangeListener *dcl = s->listeners; |
| 308 | while (dcl != NULL) { |
| 309 | if (dcl->dpy_copy) |
| 310 | dcl->dpy_copy(s, src_x, src_y, dst_x, dst_y, w, h); |
| 311 | else /* TODO */ |
| 312 | dcl->dpy_update(s, dst_x, dst_y, w, h); |
| 313 | dcl = dcl->next; |
| 314 | } |
| 315 | } |
| 316 | |
| 317 | static inline void dpy_fill(struct DisplayState *s, int x, int y, |
| 318 | int w, int h, uint32_t c) { |
| 319 | struct DisplayChangeListener *dcl = s->listeners; |
| 320 | while (dcl != NULL) { |
| 321 | if (dcl->dpy_fill) dcl->dpy_fill(s, x, y, w, h, c); |
| 322 | dcl = dcl->next; |
| 323 | } |
| 324 | } |
| 325 | |
| 326 | static inline void dpy_cursor(struct DisplayState *s, int x, int y) { |
| 327 | struct DisplayChangeListener *dcl = s->listeners; |
| 328 | while (dcl != NULL) { |
| 329 | if (dcl->dpy_text_cursor) dcl->dpy_text_cursor(s, x, y); |
| 330 | dcl = dcl->next; |
| 331 | } |
| 332 | } |
| 333 | |
| 334 | static inline int ds_get_linesize(DisplayState *ds) |
| 335 | { |
| 336 | return ds->surface->linesize; |
| 337 | } |
| 338 | |
| 339 | static inline uint8_t* ds_get_data(DisplayState *ds) |
| 340 | { |
| 341 | return ds->surface->data; |
| 342 | } |
| 343 | |
| 344 | static inline int ds_get_width(DisplayState *ds) |
| 345 | { |
| 346 | return ds->surface->width; |
| 347 | } |
| 348 | |
| 349 | static inline int ds_get_height(DisplayState *ds) |
| 350 | { |
| 351 | return ds->surface->height; |
| 352 | } |
| 353 | |
| 354 | static inline int ds_get_bits_per_pixel(DisplayState *ds) |
| 355 | { |
| 356 | return ds->surface->pf.bits_per_pixel; |
| 357 | } |
| 358 | |
| 359 | static inline int ds_get_bytes_per_pixel(DisplayState *ds) |
| 360 | { |
| 361 | return ds->surface->pf.bytes_per_pixel; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 362 | } |
| 363 | |
| 364 | typedef unsigned long console_ch_t; |
| 365 | static inline void console_write_ch(console_ch_t *dest, uint32_t ch) |
| 366 | { |
David Turner | 025c32f | 2010-09-10 14:52:42 +0200 | [diff] [blame] | 367 | if (!(ch & 0xff)) |
| 368 | ch |= ' '; |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 369 | cpu_to_le32wu((uint32_t *) dest, ch); |
| 370 | } |
| 371 | |
| 372 | typedef void (*vga_hw_update_ptr)(void *); |
| 373 | typedef void (*vga_hw_invalidate_ptr)(void *); |
| 374 | typedef void (*vga_hw_screen_dump_ptr)(void *, const char *); |
| 375 | typedef void (*vga_hw_text_update_ptr)(void *, console_ch_t *); |
| 376 | |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 377 | DisplayState *graphic_console_init(vga_hw_update_ptr update, |
| 378 | vga_hw_invalidate_ptr invalidate, |
| 379 | vga_hw_screen_dump_ptr screen_dump, |
| 380 | vga_hw_text_update_ptr text_update, |
| 381 | void *opaque); |
| 382 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 383 | void vga_hw_update(void); |
| 384 | void vga_hw_invalidate(void); |
| 385 | void vga_hw_screen_dump(const char *filename); |
| 386 | void vga_hw_text_update(console_ch_t *chardata); |
| 387 | |
| 388 | int is_graphic_console(void); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 389 | int is_fixedsize_console(void); |
David Turner | f52506f | 2010-09-10 16:11:22 +0200 | [diff] [blame] | 390 | CharDriverState *text_console_init(QemuOpts *opts); |
| 391 | CharDriverState* text_console_init_compat(const char *label, const char *p); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 392 | void text_consoles_set_display(DisplayState *ds); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 393 | void console_select(unsigned int index); |
| 394 | void console_color_init(DisplayState *ds); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 395 | void qemu_console_resize(DisplayState *ds, int width, int height); |
| 396 | void qemu_console_copy(DisplayState *ds, int src_x, int src_y, |
| 397 | int dst_x, int dst_y, int w, int h); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 398 | |
| 399 | /* sdl.c */ |
| 400 | void sdl_display_init(DisplayState *ds, int full_screen, int no_frame); |
| 401 | |
| 402 | /* cocoa.m */ |
| 403 | void cocoa_display_init(DisplayState *ds, int full_screen); |
| 404 | |
| 405 | /* vnc.c */ |
| 406 | void vnc_display_init(DisplayState *ds); |
| 407 | void vnc_display_close(DisplayState *ds); |
| 408 | int vnc_display_open(DisplayState *ds, const char *display); |
| 409 | int vnc_display_password(DisplayState *ds, const char *password); |
David 'Digit' Turner | 5d8f37a | 2009-09-14 14:32:27 -0700 | [diff] [blame] | 410 | void do_info_vnc(Monitor *mon); |
| 411 | char *vnc_display_local_addr(DisplayState *ds); |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 412 | |
| 413 | /* curses.c */ |
| 414 | void curses_display_init(DisplayState *ds, int full_screen); |
| 415 | |
David Turner | f52506f | 2010-09-10 16:11:22 +0200 | [diff] [blame] | 416 | #ifdef CONFIG_ANDROID |
David 'Digit' Turner | 94702b0 | 2011-01-20 02:46:33 +0100 | [diff] [blame] | 417 | void android_display_reset(DisplayState* ds, int width, int height, int bitspp); |
David Turner | f52506f | 2010-09-10 16:11:22 +0200 | [diff] [blame] | 418 | #endif |
| 419 | |
The Android Open Source Project | 8b23a6c | 2009-03-03 19:30:32 -0800 | [diff] [blame] | 420 | #endif |