Statistics
| Branch: | Revision:

root / console.h @ 46aaebff

History | View | Annotate | Download (11.5 kB)

1
#ifndef CONSOLE_H
2
#define CONSOLE_H
3

    
4
#include "qemu-char.h"
5
#include "qdict.h"
6
#include "notify.h"
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

    
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

    
19
/* in ms */
20
#define GUI_REFRESH_INTERVAL 30
21

    
22
typedef void QEMUPutKBDEvent(void *opaque, int keycode);
23
typedef void QEMUPutLEDEvent(void *opaque, int ledstate);
24
typedef void QEMUPutMouseEvent(void *opaque, int dx, int dy, int dz, int buttons_state);
25

    
26
typedef struct QEMUPutMouseEntry {
27
    QEMUPutMouseEvent *qemu_put_mouse_event;
28
    void *qemu_put_mouse_event_opaque;
29
    int qemu_put_mouse_event_absolute;
30
    char *qemu_put_mouse_event_name;
31

    
32
    int index;
33

    
34
    /* used internally by qemu for handling mice */
35
    QTAILQ_ENTRY(QEMUPutMouseEntry) node;
36
} QEMUPutMouseEntry;
37

    
38
typedef struct QEMUPutLEDEntry {
39
    QEMUPutLEDEvent *put_led;
40
    void *opaque;
41
    QTAILQ_ENTRY(QEMUPutLEDEntry) next;
42
} QEMUPutLEDEntry;
43

    
44
void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque);
45
void qemu_remove_kbd_event_handler(void);
46
QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
47
                                                void *opaque, int absolute,
48
                                                const char *name);
49
void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry);
50
void qemu_activate_mouse_event_handler(QEMUPutMouseEntry *entry);
51

    
52
QEMUPutLEDEntry *qemu_add_led_event_handler(QEMUPutLEDEvent *func, void *opaque);
53
void qemu_remove_led_event_handler(QEMUPutLEDEntry *entry);
54

    
55
void kbd_put_keycode(int keycode);
56
void kbd_put_ledstate(int ledstate);
57
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
58

    
59
/* Does the current mouse generate absolute events */
60
int kbd_mouse_is_absolute(void);
61
void qemu_add_mouse_mode_change_notifier(Notifier *notify);
62
void qemu_remove_mouse_mode_change_notifier(Notifier *notify);
63

    
64
/* Of all the mice, is there one that generates absolute events */
65
int kbd_mouse_has_absolute(void);
66

    
67
struct MouseTransformInfo {
68
    /* Touchscreen resolution */
69
    int x;
70
    int y;
71
    /* Calibration values as used/generated by tslib */
72
    int a[7];
73
};
74

    
75
void do_info_mice_print(Monitor *mon, const QObject *data);
76
void do_info_mice(Monitor *mon, QObject **ret_data);
77
void do_mouse_set(Monitor *mon, const QDict *qdict);
78

    
79
/* keysym is a unicode code except for special keys (see QEMU_KEY_xxx
80
   constants) */
81
#define QEMU_KEY_ESC1(c) ((c) | 0xe100)
82
#define QEMU_KEY_BACKSPACE  0x007f
83
#define QEMU_KEY_UP         QEMU_KEY_ESC1('A')
84
#define QEMU_KEY_DOWN       QEMU_KEY_ESC1('B')
85
#define QEMU_KEY_RIGHT      QEMU_KEY_ESC1('C')
86
#define QEMU_KEY_LEFT       QEMU_KEY_ESC1('D')
87
#define QEMU_KEY_HOME       QEMU_KEY_ESC1(1)
88
#define QEMU_KEY_END        QEMU_KEY_ESC1(4)
89
#define QEMU_KEY_PAGEUP     QEMU_KEY_ESC1(5)
90
#define QEMU_KEY_PAGEDOWN   QEMU_KEY_ESC1(6)
91
#define QEMU_KEY_DELETE     QEMU_KEY_ESC1(3)
92

    
93
#define QEMU_KEY_CTRL_UP         0xe400
94
#define QEMU_KEY_CTRL_DOWN       0xe401
95
#define QEMU_KEY_CTRL_LEFT       0xe402
96
#define QEMU_KEY_CTRL_RIGHT      0xe403
97
#define QEMU_KEY_CTRL_HOME       0xe404
98
#define QEMU_KEY_CTRL_END        0xe405
99
#define QEMU_KEY_CTRL_PAGEUP     0xe406
100
#define QEMU_KEY_CTRL_PAGEDOWN   0xe407
101

    
102
void kbd_put_keysym(int keysym);
103

    
104
/* consoles */
105

    
106
#define QEMU_BIG_ENDIAN_FLAG    0x01
107
#define QEMU_ALLOCATED_FLAG     0x02
108
#define QEMU_REALPIXELS_FLAG    0x04
109

    
110
struct PixelFormat {
111
    uint8_t bits_per_pixel;
112
    uint8_t bytes_per_pixel;
113
    uint8_t depth; /* color depth in bits */
114
    uint32_t rmask, gmask, bmask, amask;
115
    uint8_t rshift, gshift, bshift, ashift;
116
    uint8_t rmax, gmax, bmax, amax;
117
    uint8_t rbits, gbits, bbits, abits;
118
};
119

    
120
struct DisplaySurface {
121
    uint8_t flags;
122
    int width;
123
    int height;
124
    int linesize;        /* bytes per line */
125
    uint8_t *data;
126

    
127
    struct PixelFormat pf;
128
};
129

    
130
/* cursor data format is 32bit RGBA */
131
typedef struct QEMUCursor {
132
    int                 width, height;
133
    int                 hot_x, hot_y;
134
    int                 refcount;
135
    uint32_t            data[];
136
} QEMUCursor;
137

    
138
QEMUCursor *cursor_alloc(int width, int height);
139
void cursor_get(QEMUCursor *c);
140
void cursor_put(QEMUCursor *c);
141
QEMUCursor *cursor_builtin_hidden(void);
142
QEMUCursor *cursor_builtin_left_ptr(void);
143
void cursor_print_ascii_art(QEMUCursor *c, const char *prefix);
144
int cursor_get_mono_bpl(QEMUCursor *c);
145
void cursor_set_mono(QEMUCursor *c,
146
                     uint32_t foreground, uint32_t background, uint8_t *image,
147
                     int transparent, uint8_t *mask);
148
void cursor_get_mono_image(QEMUCursor *c, int foreground, uint8_t *mask);
149
void cursor_get_mono_mask(QEMUCursor *c, int transparent, uint8_t *mask);
150

    
151
struct DisplayChangeListener {
152
    int idle;
153
    uint64_t gui_timer_interval;
154

    
155
    void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
156
    void (*dpy_resize)(struct DisplayState *s);
157
    void (*dpy_setdata)(struct DisplayState *s);
158
    void (*dpy_refresh)(struct DisplayState *s);
159
    void (*dpy_copy)(struct DisplayState *s, int src_x, int src_y,
160
                     int dst_x, int dst_y, int w, int h);
161
    void (*dpy_fill)(struct DisplayState *s, int x, int y,
162
                     int w, int h, uint32_t c);
163
    void (*dpy_text_cursor)(struct DisplayState *s, int x, int y);
164

    
165
    struct DisplayChangeListener *next;
166
};
167

    
168
struct DisplayAllocator {
169
    DisplaySurface* (*create_displaysurface)(int width, int height);
170
    DisplaySurface* (*resize_displaysurface)(DisplaySurface *surface, int width, int height);
171
    void (*free_displaysurface)(DisplaySurface *surface);
172
};
173

    
174
struct DisplayState {
175
    struct DisplaySurface *surface;
176
    void *opaque;
177
    struct QEMUTimer *gui_timer;
178

    
179
    struct DisplayAllocator* allocator;
180
    struct DisplayChangeListener* listeners;
181

    
182
    void (*mouse_set)(int x, int y, int on);
183
    void (*cursor_define)(QEMUCursor *cursor);
184

    
185
    struct DisplayState *next;
186
};
187

    
188
void register_displaystate(DisplayState *ds);
189
DisplayState *get_displaystate(void);
190
DisplaySurface* qemu_create_displaysurface_from(int width, int height, int bpp,
191
                                                int linesize, uint8_t *data);
192
PixelFormat qemu_different_endianness_pixelformat(int bpp);
193
PixelFormat qemu_default_pixelformat(int bpp);
194

    
195
DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da);
196

    
197
static inline DisplaySurface* qemu_create_displaysurface(DisplayState *ds, int width, int height)
198
{
199
    return ds->allocator->create_displaysurface(width, height);    
200
}
201

    
202
static inline DisplaySurface* qemu_resize_displaysurface(DisplayState *ds, int width, int height)
203
{
204
    return ds->allocator->resize_displaysurface(ds->surface, width, height);
205
}
206

    
207
static inline void qemu_free_displaysurface(DisplayState *ds)
208
{
209
    ds->allocator->free_displaysurface(ds->surface);
210
}
211

    
212
static inline int is_surface_bgr(DisplaySurface *surface)
213
{
214
    if (surface->pf.bits_per_pixel == 32 && surface->pf.rshift == 0)
215
        return 1;
216
    else
217
        return 0;
218
}
219

    
220
static inline int is_buffer_shared(DisplaySurface *surface)
221
{
222
    return (!(surface->flags & QEMU_ALLOCATED_FLAG) &&
223
            !(surface->flags & QEMU_REALPIXELS_FLAG));
224
}
225

    
226
static inline void register_displaychangelistener(DisplayState *ds, DisplayChangeListener *dcl)
227
{
228
    dcl->next = ds->listeners;
229
    ds->listeners = dcl;
230
}
231

    
232
static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
233
{
234
    struct DisplayChangeListener *dcl = s->listeners;
235
    while (dcl != NULL) {
236
        dcl->dpy_update(s, x, y, w, h);
237
        dcl = dcl->next;
238
    }
239
}
240

    
241
static inline void dpy_resize(DisplayState *s)
242
{
243
    struct DisplayChangeListener *dcl = s->listeners;
244
    while (dcl != NULL) {
245
        dcl->dpy_resize(s);
246
        dcl = dcl->next;
247
    }
248
}
249

    
250
static inline void dpy_setdata(DisplayState *s)
251
{
252
    struct DisplayChangeListener *dcl = s->listeners;
253
    while (dcl != NULL) {
254
        if (dcl->dpy_setdata) dcl->dpy_setdata(s);
255
        dcl = dcl->next;
256
    }
257
}
258

    
259
static inline void dpy_refresh(DisplayState *s)
260
{
261
    struct DisplayChangeListener *dcl = s->listeners;
262
    while (dcl != NULL) {
263
        if (dcl->dpy_refresh) dcl->dpy_refresh(s);
264
        dcl = dcl->next;
265
    }
266
}
267

    
268
static inline void dpy_copy(struct DisplayState *s, int src_x, int src_y,
269
                             int dst_x, int dst_y, int w, int h) {
270
    struct DisplayChangeListener *dcl = s->listeners;
271
    while (dcl != NULL) {
272
        if (dcl->dpy_copy)
273
            dcl->dpy_copy(s, src_x, src_y, dst_x, dst_y, w, h);
274
        else /* TODO */
275
            dcl->dpy_update(s, dst_x, dst_y, w, h);
276
        dcl = dcl->next;
277
    }
278
}
279

    
280
static inline void dpy_fill(struct DisplayState *s, int x, int y,
281
                             int w, int h, uint32_t c) {
282
    struct DisplayChangeListener *dcl = s->listeners;
283
    while (dcl != NULL) {
284
        if (dcl->dpy_fill) dcl->dpy_fill(s, x, y, w, h, c);
285
        dcl = dcl->next;
286
    }
287
}
288

    
289
static inline void dpy_cursor(struct DisplayState *s, int x, int y) {
290
    struct DisplayChangeListener *dcl = s->listeners;
291
    while (dcl != NULL) {
292
        if (dcl->dpy_text_cursor) dcl->dpy_text_cursor(s, x, y);
293
        dcl = dcl->next;
294
    }
295
}
296

    
297
static inline int ds_get_linesize(DisplayState *ds)
298
{
299
    return ds->surface->linesize;
300
}
301

    
302
static inline uint8_t* ds_get_data(DisplayState *ds)
303
{
304
    return ds->surface->data;
305
}
306

    
307
static inline int ds_get_width(DisplayState *ds)
308
{
309
    return ds->surface->width;
310
}
311

    
312
static inline int ds_get_height(DisplayState *ds)
313
{
314
    return ds->surface->height;
315
}
316

    
317
static inline int ds_get_bits_per_pixel(DisplayState *ds)
318
{
319
    return ds->surface->pf.bits_per_pixel;
320
}
321

    
322
static inline int ds_get_bytes_per_pixel(DisplayState *ds)
323
{
324
    return ds->surface->pf.bytes_per_pixel;
325
}
326

    
327
typedef unsigned long console_ch_t;
328
static inline void console_write_ch(console_ch_t *dest, uint32_t ch)
329
{
330
    if (!(ch & 0xff))
331
        ch |= ' ';
332
    cpu_to_le32wu((uint32_t *) dest, ch);
333
}
334

    
335
typedef void (*vga_hw_update_ptr)(void *);
336
typedef void (*vga_hw_invalidate_ptr)(void *);
337
typedef void (*vga_hw_screen_dump_ptr)(void *, const char *);
338
typedef void (*vga_hw_text_update_ptr)(void *, console_ch_t *);
339

    
340
DisplayState *graphic_console_init(vga_hw_update_ptr update,
341
                                   vga_hw_invalidate_ptr invalidate,
342
                                   vga_hw_screen_dump_ptr screen_dump,
343
                                   vga_hw_text_update_ptr text_update,
344
                                   void *opaque);
345

    
346
void vga_hw_update(void);
347
void vga_hw_invalidate(void);
348
void vga_hw_screen_dump(const char *filename);
349
void vga_hw_text_update(console_ch_t *chardata);
350

    
351
int is_graphic_console(void);
352
int is_fixedsize_console(void);
353
CharDriverState *text_console_init(QemuOpts *opts);
354
void text_consoles_set_display(DisplayState *ds);
355
void console_select(unsigned int index);
356
void console_color_init(DisplayState *ds);
357
void qemu_console_resize(DisplayState *ds, int width, int height);
358
void qemu_console_copy(DisplayState *ds, int src_x, int src_y,
359
                       int dst_x, int dst_y, int w, int h);
360

    
361
/* sdl.c */
362
void sdl_display_init(DisplayState *ds, int full_screen, int no_frame);
363

    
364
/* cocoa.m */
365
void cocoa_display_init(DisplayState *ds, int full_screen);
366

    
367
/* vnc.c */
368
void vnc_display_init(DisplayState *ds);
369
void vnc_display_close(DisplayState *ds);
370
int vnc_display_open(DisplayState *ds, const char *display);
371
int vnc_display_password(DisplayState *ds, const char *password);
372
void do_info_vnc_print(Monitor *mon, const QObject *data);
373
void do_info_vnc(Monitor *mon, QObject **ret_data);
374
char *vnc_display_local_addr(DisplayState *ds);
375

    
376
/* curses.c */
377
void curses_display_init(DisplayState *ds, int full_screen);
378

    
379
#endif