qmp-commands: move 'chardev-add' doc to schema

[qemu.git] / ui / console.c

diff --git a/ui/console.c b/ui/console.c
index 8027ba7d8f4a8611757828eaeac2d0bf7d26c886..b9575f2ee59aa55af4f9e160544f30bfee93e5c9 100644 (file)
--- a/ui/console.c
+++ b/ui/console.c
@@ -123,6 +123,8 @@ struct QemuConsole {
     DisplaySurface *surface;
     int dcls;
     DisplayChangeListener *gl;
     DisplaySurface *surface;
     int dcls;
     DisplayChangeListener *gl;

+    bool gl_block;
+    int window_id;

 
     /* Graphic console state.  */
     Object *device;
 
     /* Graphic console state.  */
     Object *device;


@@ -264,14 +266,24 @@ void graphic_hw_update(QemuConsole *con)
 
 void graphic_hw_gl_block(QemuConsole *con, bool block)
 {
 
 void graphic_hw_gl_block(QemuConsole *con, bool block)
 {

-    if (!con) {
-        con = active_console;
-    }
-    if (con && con->hw_ops->gl_block) {
+    assert(con != NULL);
+
+    con->gl_block = block;
+    if (con->hw_ops->gl_block) {

         con->hw_ops->gl_block(con->hw, block);
     }
 }
 
         con->hw_ops->gl_block(con->hw, block);
     }
 }
 

+int qemu_console_get_window_id(QemuConsole *con)
+{
+    return con->window_id;
+}
+
+void qemu_console_set_window_id(QemuConsole *con, int window_id)
+{
+    con->window_id = window_id;
+}
+

 void graphic_hw_invalidate(QemuConsole *con)
 {
     if (!con) {
 void graphic_hw_invalidate(QemuConsole *con)
 {
     if (!con) {


@@ -1082,6 +1094,7 @@ static void kbd_send_chars(void *opaque)
 void kbd_put_keysym_console(QemuConsole *s, int keysym)
 {
     uint8_t buf[16], *q;
 void kbd_put_keysym_console(QemuConsole *s, int keysym)
 {
     uint8_t buf[16], *q;

+    CharBackend *be;

     int c;
 
     if (!s || (s->console_type == GRAPHIC_CONSOLE))
     int c;
 
     if (!s || (s->console_type == GRAPHIC_CONSOLE))


@@ -1124,7 +1137,8 @@ void kbd_put_keysym_console(QemuConsole *s, int keysym)
         if (s->echo) {
             console_puts(s->chr, buf, q - buf);
         }
         if (s->echo) {
             console_puts(s->chr, buf, q - buf);
         }

-        if (s->chr->chr_read) {
+        be = s->chr->be;
+        if (be && be->chr_read) {

             qemu_fifo_write(&s->out_fifo, buf, q - buf);
             kbd_send_chars(s);
         }
             qemu_fifo_write(&s->out_fifo, buf, q - buf);
             kbd_send_chars(s);
         }


@@ -1142,6 +1156,7 @@ static const int qcode_to_keysym[Q_KEY_CODE__MAX] = {
     [Q_KEY_CODE_PGUP]   = QEMU_KEY_PAGEUP,
     [Q_KEY_CODE_PGDN]   = QEMU_KEY_PAGEDOWN,
     [Q_KEY_CODE_DELETE] = QEMU_KEY_DELETE,
     [Q_KEY_CODE_PGUP]   = QEMU_KEY_PAGEUP,
     [Q_KEY_CODE_PGDN]   = QEMU_KEY_PAGEDOWN,
     [Q_KEY_CODE_DELETE] = QEMU_KEY_DELETE,

+    [Q_KEY_CODE_BACKSPACE] = QEMU_KEY_BACKSPACE,

 };
 
 bool kbd_put_qcode_console(QemuConsole *s, int qcode)
 };
 
 bool kbd_put_qcode_console(QemuConsole *s, int qcode)


@@ -1292,6 +1307,17 @@ DisplaySurface *qemu_create_displaysurface_from(int width, int height,
     return surface;
 }
 
     return surface;
 }
 

+DisplaySurface *qemu_create_displaysurface_pixman(pixman_image_t *image)
+{
+    DisplaySurface *surface = g_new0(DisplaySurface, 1);
+
+    trace_displaysurface_create_pixman(surface);
+    surface->format = pixman_image_get_format(image);
+    surface->image = pixman_image_ref(image);
+
+    return surface;
+}
+

 static void qemu_unmap_displaysurface_guestmem(pixman_image_t *image,
                                                void *unused)
 {
 static void qemu_unmap_displaysurface_guestmem(pixman_image_t *image,
                                                void *unused)
 {


@@ -1442,16 +1468,21 @@ bool dpy_ui_info_supported(QemuConsole *con)
 int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info)
 {
     assert(con != NULL);
 int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info)
 {
     assert(con != NULL);

-    con->ui_info = *info;
+

     if (!dpy_ui_info_supported(con)) {
         return -1;
     }
     if (!dpy_ui_info_supported(con)) {
         return -1;
     }

+    if (memcmp(&con->ui_info, info, sizeof(con->ui_info)) == 0) {
+        /* nothing changed -- ignore */
+        return 0;
+    }

 
     /*
      * Typically we get a flood of these as the user resizes the window.
      * Wait until the dust has settled (one second without updates), then
      * go notify the guest.
      */
 
     /*
      * Typically we get a flood of these as the user resizes the window.
      * Wait until the dust has settled (one second without updates), then
      * go notify the guest.
      */

+    con->ui_info = *info;

     timer_mod(con->ui_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
     return 0;
 }
     timer_mod(con->ui_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
     return 0;
 }


@@ -1693,11 +1724,13 @@ QEMUGLContext dpy_gl_ctx_get_current(QemuConsole *con)
 
 void dpy_gl_scanout(QemuConsole *con,
                     uint32_t backing_id, bool backing_y_0_top,
 
 void dpy_gl_scanout(QemuConsole *con,
                     uint32_t backing_id, bool backing_y_0_top,

+                    uint32_t backing_width, uint32_t backing_height,

                     uint32_t x, uint32_t y, uint32_t width, uint32_t height)
 {
     assert(con->gl);
     con->gl->ops->dpy_gl_scanout(con->gl, backing_id,
                                  backing_y_0_top,
                     uint32_t x, uint32_t y, uint32_t width, uint32_t height)
 {
     assert(con->gl);
     con->gl->ops->dpy_gl_scanout(con->gl, backing_id,
                                  backing_y_0_top,

+                                 backing_width, backing_height,

                                  x, y, width, height);
 }
 
                                  x, y, width, height);
 }
 


@@ -1860,6 +1893,12 @@ bool qemu_console_is_fixedsize(QemuConsole *con)
     return con && (con->console_type != TEXT_CONSOLE);
 }
 
     return con && (con->console_type != TEXT_CONSOLE);
 }
 

+bool qemu_console_is_gl_blocked(QemuConsole *con)
+{
+    assert(con != NULL);
+    return con->gl_block;
+}
+

 char *qemu_console_get_label(QemuConsole *con)
 {
     if (con->console_type == GRAPHIC_CONSOLE) {
 char *qemu_console_get_label(QemuConsole *con)
 {
     if (con->console_type == GRAPHIC_CONSOLE) {


@@ -2007,8 +2046,6 @@ static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
     }
 
     qemu_chr_be_generic_open(chr);
     }
 
     qemu_chr_be_generic_open(chr);

-    if (chr->init)
-        chr->init(chr);

 }
 
 static CharDriverState *text_console_init(ChardevVC *vc, Error **errp)
 }
 
 static CharDriverState *text_console_init(ChardevVC *vc, Error **errp)


@@ -2053,10 +2090,6 @@ static CharDriverState *text_console_init(ChardevVC *vc, Error **errp)
     s->chr = chr;
     chr->opaque = s;
     chr->chr_set_echo = text_console_set_echo;
     s->chr = chr;
     chr->opaque = s;
     chr->chr_set_echo = text_console_set_echo;

-    /* console/chardev init sometimes completes elsewhere in a 2nd
-     * stage, so defer OPENED events until they are fully initialized
-     */
-    chr->explicit_be_open = true;

 
     if (display_state) {
         text_console_do_init(chr, display_state);
 
     if (display_state) {
         text_console_do_init(chr, display_state);


@@ -2067,9 +2100,14 @@ static CharDriverState *text_console_init(ChardevVC *vc, Error **errp)
 static VcHandler *vc_handler = text_console_init;
 
 static CharDriverState *vc_init(const char *id, ChardevBackend *backend,
 static VcHandler *vc_handler = text_console_init;
 
 static CharDriverState *vc_init(const char *id, ChardevBackend *backend,

-                                ChardevReturn *ret, Error **errp)
+                                ChardevReturn *ret, bool *be_opened,
+                                Error **errp)

 {
 {

-    return vc_handler(backend->u.vc, errp);
+    /* console/chardev init sometimes completes elsewhere in a 2nd
+     * stage, so defer OPENED events until they are fully initialized
+     */
+    *be_opened = false;
+    return vc_handler(backend->u.vc.data, errp);

 }
 
 void register_vc_handler(VcHandler *handler)
 }
 
 void register_vc_handler(VcHandler *handler)


@@ -2082,6 +2120,13 @@ void qemu_console_resize(QemuConsole *s, int width, int height)
     DisplaySurface *surface;
 
     assert(s->console_type == GRAPHIC_CONSOLE);
     DisplaySurface *surface;
 
     assert(s->console_type == GRAPHIC_CONSOLE);

+
+    if (s->surface &&
+        pixman_image_get_width(s->surface->image) == width &&
+        pixman_image_get_height(s->surface->image) == height) {
+        return;
+    }
+

     surface = qemu_create_displaysurface(width, height);
     dpy_gfx_replace_surface(s, surface);
 }
     surface = qemu_create_displaysurface(width, height);
     dpy_gfx_replace_surface(s, surface);
 }


@@ -2111,7 +2156,7 @@ static void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend,
     int val;
     ChardevVC *vc;
 
     int val;
     ChardevVC *vc;
 

-    vc = backend->u.vc = g_new0(ChardevVC, 1);
+    vc = backend->u.vc.data = g_new0(ChardevVC, 1);

     qemu_chr_parse_common(opts, qapi_ChardevVC_base(vc));
 
     val = qemu_opt_get_number(opts, "width", 0);
     qemu_chr_parse_common(opts, qapi_ChardevVC_base(vc));
 
     val = qemu_opt_get_number(opts, "width", 0);