← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to console.h

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
console.h
9
9
#define MOUSE_EVENT_RBUTTON 0x02
10
10
#define MOUSE_EVENT_MBUTTON 0x04
11
11
 
 
12
/* in ms */
 
13
#define GUI_REFRESH_INTERVAL 30
 
14
 
12
15
typedef void QEMUPutKBDEvent(void *opaque, int keycode);
13
16
typedef void QEMUPutMouseEvent(void *opaque, int dx, int dy, int dz, int buttons_state);
14
17
 
32
35
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state);
33
36
int kbd_mouse_is_absolute(void);
34
37
 
 
38
struct mouse_transform_info_s {
 
39
    /* Touchscreen resolution */
 
40
    int x;
 
41
    int y;
 
42
    /* Calibration values as used/generated by tslib */
 
43
    int a[7];
 
44
};
 
45
 
35
46
void do_info_mice(void);
36
47
void do_mouse_set(int index);
37
48
 
62
73
 
63
74
/* consoles */
64
75
 
65
 
struct DisplayState {
66
 
    uint8_t *data;
67
 
    int linesize;
68
 
    int depth;
69
 
    int bgr; /* BGR color order instead of RGB. Only valid for depth == 32 */
 
76
#define QEMU_BIG_ENDIAN_FLAG    0x01
 
77
#define QEMU_ALLOCATED_FLAG     0x02
 
78
 
 
79
struct PixelFormat {
 
80
    uint8_t bits_per_pixel;
 
81
    uint8_t bytes_per_pixel;
 
82
    uint8_t depth; /* color depth in bits */
 
83
    uint32_t rmask, gmask, bmask, amask;
 
84
    uint8_t rshift, gshift, bshift, ashift;
 
85
    uint8_t rmax, gmax, bmax, amax;
 
86
    uint8_t rbits, gbits, bbits, abits;
 
87
};
 
88
 
 
89
struct DisplaySurface {
 
90
    uint8_t flags;
70
91
    int width;
71
92
    int height;
72
 
    void *opaque;
73
 
    struct QEMUTimer *gui_timer;
 
93
    int linesize;        /* bytes per line */
 
94
    uint8_t *data;
 
95
 
 
96
    struct PixelFormat pf;
 
97
};
 
98
 
 
99
struct DisplayChangeListener {
 
100
    int idle;
 
101
    uint64_t gui_timer_interval;
74
102
 
75
103
    void (*dpy_update)(struct DisplayState *s, int x, int y, int w, int h);
76
 
    void (*dpy_resize)(struct DisplayState *s, int w, int h);
 
104
    void (*dpy_resize)(struct DisplayState *s);
 
105
    void (*dpy_setdata)(struct DisplayState *s);
77
106
    void (*dpy_refresh)(struct DisplayState *s);
78
107
    void (*dpy_copy)(struct DisplayState *s, int src_x, int src_y,
79
108
                     int dst_x, int dst_y, int w, int h);
80
109
    void (*dpy_fill)(struct DisplayState *s, int x, int y,
81
110
                     int w, int h, uint32_t c);
 
111
    void (*dpy_text_cursor)(struct DisplayState *s, int x, int y);
 
112
 
 
113
    struct DisplayChangeListener *next;
 
114
};
 
115
 
 
116
struct DisplayState {
 
117
    struct DisplaySurface *surface;
 
118
    void *opaque;
 
119
    struct QEMUTimer *gui_timer;
 
120
 
 
121
    struct DisplayChangeListener* listeners;
 
122
 
82
123
    void (*mouse_set)(int x, int y, int on);
83
124
    void (*cursor_define)(int width, int height, int bpp, int hot_x, int hot_y,
84
125
                          uint8_t *image, uint8_t *mask);
 
126
 
 
127
    struct DisplayState *next;
85
128
};
86
129
 
 
130
void register_displaystate(DisplayState *ds);
 
131
DisplayState *get_displaystate(void);
 
132
DisplaySurface* qemu_create_displaysurface(int width, int height, int bpp, int linesize);
 
133
DisplaySurface* qemu_resize_displaysurface(DisplaySurface *surface,
 
134
                                           int width, int height, int bpp, int linesize);
 
135
DisplaySurface* qemu_create_displaysurface_from(int width, int height, int bpp,
 
136
                                                int linesize, uint8_t *data);
 
137
void qemu_free_displaysurface(DisplaySurface *surface);
 
138
PixelFormat qemu_different_endianness_pixelformat(int bpp);
 
139
PixelFormat qemu_default_pixelformat(int bpp);
 
140
 
 
141
static inline int is_buffer_shared(DisplaySurface *surface)
 
142
{
 
143
    return (!(surface->flags & QEMU_ALLOCATED_FLAG));
 
144
}
 
145
 
 
146
static inline void register_displaychangelistener(DisplayState *ds, DisplayChangeListener *dcl)
 
147
{
 
148
    dcl->next = ds->listeners;
 
149
    ds->listeners = dcl;
 
150
}
 
151
 
87
152
static inline void dpy_update(DisplayState *s, int x, int y, int w, int h)
88
153
{
89
 
    s->dpy_update(s, x, y, w, h);
90
 
}
91
 
 
92
 
static inline void dpy_resize(DisplayState *s, int w, int h)
93
 
{
94
 
    s->dpy_resize(s, w, h);
 
154
    struct DisplayChangeListener *dcl = s->listeners;
 
155
    while (dcl != NULL) {
 
156
        dcl->dpy_update(s, x, y, w, h);
 
157
        dcl = dcl->next;
 
158
    }
 
159
}
 
160
 
 
161
static inline void dpy_resize(DisplayState *s)
 
162
{
 
163
    struct DisplayChangeListener *dcl = s->listeners;
 
164
    while (dcl != NULL) {
 
165
        dcl->dpy_resize(s);
 
166
        dcl = dcl->next;
 
167
    }
 
168
}
 
169
 
 
170
static inline void dpy_setdata(DisplayState *s)
 
171
{
 
172
    struct DisplayChangeListener *dcl = s->listeners;
 
173
    while (dcl != NULL) {
 
174
        if (dcl->dpy_setdata) dcl->dpy_setdata(s);
 
175
        dcl = dcl->next;
 
176
    }
 
177
}
 
178
 
 
179
static inline void dpy_refresh(DisplayState *s)
 
180
{
 
181
    struct DisplayChangeListener *dcl = s->listeners;
 
182
    while (dcl != NULL) {
 
183
        if (dcl->dpy_refresh) dcl->dpy_refresh(s);
 
184
        dcl = dcl->next;
 
185
    }
 
186
}
 
187
 
 
188
static inline void dpy_copy(struct DisplayState *s, int src_x, int src_y,
 
189
                             int dst_x, int dst_y, int w, int h) {
 
190
    struct DisplayChangeListener *dcl = s->listeners;
 
191
    while (dcl != NULL) {
 
192
        if (dcl->dpy_copy)
 
193
            dcl->dpy_copy(s, src_x, src_y, dst_x, dst_y, w, h);
 
194
        else /* TODO */
 
195
            dcl->dpy_update(s, dst_x, dst_y, w, h);
 
196
        dcl = dcl->next;
 
197
    }
 
198
}
 
199
 
 
200
static inline void dpy_fill(struct DisplayState *s, int x, int y,
 
201
                             int w, int h, uint32_t c) {
 
202
    struct DisplayChangeListener *dcl = s->listeners;
 
203
    while (dcl != NULL) {
 
204
        if (dcl->dpy_fill) dcl->dpy_fill(s, x, y, w, h, c);
 
205
        dcl = dcl->next;
 
206
    }
 
207
}
 
208
 
 
209
static inline void dpy_cursor(struct DisplayState *s, int x, int y) {
 
210
    struct DisplayChangeListener *dcl = s->listeners;
 
211
    while (dcl != NULL) {
 
212
        if (dcl->dpy_text_cursor) dcl->dpy_text_cursor(s, x, y);
 
213
        dcl = dcl->next;
 
214
    }
 
215
}
 
216
 
 
217
static inline int ds_get_linesize(DisplayState *ds)
 
218
{
 
219
    return ds->surface->linesize;
 
220
}
 
221
 
 
222
static inline uint8_t* ds_get_data(DisplayState *ds)
 
223
{
 
224
    return ds->surface->data;
 
225
}
 
226
 
 
227
static inline int ds_get_width(DisplayState *ds)
 
228
{
 
229
    return ds->surface->width;
 
230
}
 
231
 
 
232
static inline int ds_get_height(DisplayState *ds)
 
233
{
 
234
    return ds->surface->height;
 
235
}
 
236
 
 
237
static inline int ds_get_bits_per_pixel(DisplayState *ds)
 
238
{
 
239
    return ds->surface->pf.bits_per_pixel;
 
240
}
 
241
 
 
242
static inline int ds_get_bytes_per_pixel(DisplayState *ds)
 
243
{
 
244
    return ds->surface->pf.bytes_per_pixel;
 
245
}
 
246
 
 
247
typedef unsigned long console_ch_t;
 
248
static inline void console_write_ch(console_ch_t *dest, uint32_t ch)
 
249
{
 
250
    cpu_to_le32wu((uint32_t *) dest, ch);
95
251
}
96
252
 
97
253
typedef void (*vga_hw_update_ptr)(void *);
98
254
typedef void (*vga_hw_invalidate_ptr)(void *);
99
255
typedef void (*vga_hw_screen_dump_ptr)(void *, const char *);
100
 
 
101
 
TextConsole *graphic_console_init(DisplayState *ds, vga_hw_update_ptr update,
102
 
                                  vga_hw_invalidate_ptr invalidate,
103
 
                                  vga_hw_screen_dump_ptr screen_dump,
104
 
                                  void *opaque);
 
256
typedef void (*vga_hw_text_update_ptr)(void *, console_ch_t *);
 
257
 
 
258
DisplayState *graphic_console_init(vga_hw_update_ptr update,
 
259
                                   vga_hw_invalidate_ptr invalidate,
 
260
                                   vga_hw_screen_dump_ptr screen_dump,
 
261
                                   vga_hw_text_update_ptr text_update,
 
262
                                   void *opaque);
 
263
 
105
264
void vga_hw_update(void);
106
265
void vga_hw_invalidate(void);
107
266
void vga_hw_screen_dump(const char *filename);
 
267
void vga_hw_text_update(console_ch_t *chardata);
108
268
 
109
269
int is_graphic_console(void);
110
 
CharDriverState *text_console_init(DisplayState *ds, const char *p);
 
270
int is_fixedsize_console(void);
 
271
CharDriverState *text_console_init(const char *p);
 
272
void text_consoles_set_display(DisplayState *ds);
111
273
void console_select(unsigned int index);
112
274
void console_color_init(DisplayState *ds);
 
275
void qemu_console_resize(DisplayState *ds, int width, int height);
 
276
void qemu_console_copy(DisplayState *ds, int src_x, int src_y,
 
277
                       int dst_x, int dst_y, int w, int h);
113
278
 
114
279
/* sdl.c */
115
280
void sdl_display_init(DisplayState *ds, int full_screen, int no_frame);
124
289
int vnc_display_password(DisplayState *ds, const char *password);
125
290
void do_info_vnc(void);
126
291
 
127
 
/* x_keymap.c */
128
 
extern uint8_t _translate_keycode(const int key);
 
292
/* curses.c */
 
293
void curses_display_init(DisplayState *ds, int full_screen);
129
294
 
130
295
/* FIXME: term_printf et al should probably go elsewhere so everything
131
296
   does not need to include console.h  */
137
302
void term_print_filename(const char *filename);
138
303
void term_flush(void);
139
304
void term_print_help(void);
140
 
void monitor_readline(const char *prompt, int is_password,
141
 
                      char *buf, int buf_size);
 
305
void monitor_suspend(void);
 
306
void monitor_resume(void);
 
307
int monitor_read_bdrv_key(BlockDriverState *bs);
142
308
 
143
309
/* readline.c */
144
310
typedef void ReadLineFunc(void *opaque, const char *str);