gtk: workaround gtk2 vte resize issue

Hack isn't pretty, but gets the job done.
See source code comment for details.

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>

include/ui/console.h

@@ -81,7 +81,6 @@ void do_mouse_set(Monitor *mon, const QDict *qdict);
 #define QEMU_KEY_CTRL_PAGEUP     0xe406
 #define QEMU_KEY_CTRL_PAGEDOWN   0xe407
 
-void kbd_put_keysym_console(QemuConsole *s, int keysym);
 void kbd_put_keysym(int keysym);
 
 /* consoles */

trace-events

@@ -1045,9 +1045,10 @@ displaychangelistener_unregister(void *dcl, const char *name) "%p [ %s ]"
 ppm_save(const char *filename, void *display_surface) "%s surface=%p"
 
 # ui/gtk.c
-gd_switch(int width, int height) "width=%d, height=%d"
+gd_switch(const char *tab, int width, int height) "tab=%s, width=%d, height=%d"
-gd_update(int x, int y, int w, int h) "x=%d, y=%d, w=%d, h=%d"
+gd_update(const char *tab, int x, int y, int w, int h) "tab=%s, x=%d, y=%d, w=%d, h=%d"
-gd_key_event(int gdk_keycode, int qemu_keycode, const char *action) "translated GDK keycode %d to QEMU keycode %d (%s)"
+gd_key_event(const char *tab, int gdk_keycode, int qemu_keycode, const char *action) "tab=%s, translated GDK keycode %d to QEMU keycode %d (%s)"
+gd_grab(const char *tab, const char *device, bool on) "tab=%s, %s %d"
 
 # ui/input.c
 input_event_key_number(int conidx, int number, bool down) "con %d, key number 0x%x, down %d"

ui/console.c

@@ -143,6 +143,8 @@ struct QemuConsole {
     TextCell *cells;
     int text_x[2], text_y[2], cursor_invalidate;
     int echo;
+    bool cursor_visible_phase;
+    QEMUTimer *cursor_timer;
 
     int update_x0;
     int update_y0;
@@ -175,14 +177,10 @@ static DisplayState *display_state;
 static QemuConsole *active_console;
 static QemuConsole *consoles[MAX_CONSOLES];
 static int nb_consoles = 0;
-static bool cursor_visible_phase;
-static QEMUTimer *cursor_timer;
 
 static void text_console_do_init(CharDriverState *chr, DisplayState *ds);
 static void dpy_refresh(DisplayState *s);
 static DisplayState *get_alloc_displaystate(void);
-static void text_console_update_cursor_timer(void);
-static void text_console_update_cursor(void *opaque);
 
 static void gui_update(void *opaque)
 {
@@ -477,9 +475,6 @@ static inline void text_update_xy(QemuConsole *s, int x, int y)
 
 static void invalidate_xy(QemuConsole *s, int x, int y)
 {
-    if (!qemu_console_is_visible(s)) {
-        return;
-    }
     if (s->update_x0 > x * FONT_WIDTH)
         s->update_x0 = x * FONT_WIDTH;
     if (s->update_y0 > y * FONT_HEIGHT)
@@ -495,20 +490,25 @@ static void update_xy(QemuConsole *s, int x, int y)
     TextCell *c;
     int y1, y2;
 
+    if (!qemu_console_is_visible(s)) {
+        return;
+    }
+
     if (s->ds->have_text) {
         text_update_xy(s, x, y);
     }
 
-    y1 = (s->y_base + y) % s->total_height;
+    if (s->ds->have_gfx) {
-    y2 = y1 - s->y_displayed;
+        y1 = (s->y_base + y) % s->total_height;
-    if (y2 < 0) {
+        y2 = y1 - s->y_displayed;
-        y2 += s->total_height;
+        if (y2 < 0)
-    }
+            y2 += s->total_height;
-    if (y2 < s->height) {
+        if (y2 < s->height) {
-        c = &s->cells[y1 * s->width + x];
+            c = &s->cells[y1 * s->width + x];
-        vga_putcharxy(s, x, y2, c->ch,
+            vga_putcharxy(s, x, y2, c->ch,
-                      &(c->t_attrib));
+                          &(c->t_attrib));
-        invalidate_xy(s, x, y2);
+            invalidate_xy(s, x, y2);
+        }
     }
 }
 
@@ -518,28 +518,33 @@ static void console_show_cursor(QemuConsole *s, int show)
     int y, y1;
     int x = s->x;
 
+    if (!qemu_console_is_visible(s)) {
+        return;
+    }
+
     if (s->ds->have_text) {
         s->cursor_invalidate = 1;
     }
 
-    if (x >= s->width) {
+    if (s->ds->have_gfx) {
-        x = s->width - 1;
+        if (x >= s->width) {
-    }
+            x = s->width - 1;
-    y1 = (s->y_base + s->y) % s->total_height;
+        }
-    y = y1 - s->y_displayed;
+        y1 = (s->y_base + s->y) % s->total_height;
-    if (y < 0) {
+        y = y1 - s->y_displayed;
-        y += s->total_height;
+        if (y < 0)
-    }
+            y += s->total_height;
-    if (y < s->height) {
+        if (y < s->height) {
-        c = &s->cells[y1 * s->width + x];
+            c = &s->cells[y1 * s->width + x];
-        if (show && cursor_visible_phase) {
+            if (show && s->cursor_visible_phase) {
-            TextAttributes t_attrib = s->t_attrib_default;
+                TextAttributes t_attrib = s->t_attrib_default;
-            t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */
+                t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */
-            vga_putcharxy(s, x, y, c->ch, &t_attrib);
+                vga_putcharxy(s, x, y, c->ch, &t_attrib);
-        } else {
+            } else {
-            vga_putcharxy(s, x, y, c->ch, &(c->t_attrib));
+                vga_putcharxy(s, x, y, c->ch, &(c->t_attrib));
+            }
+            invalidate_xy(s, x, y);
         }
-        invalidate_xy(s, x, y);
     }
 }
 
@@ -549,6 +554,10 @@ static void console_refresh(QemuConsole *s)
     TextCell *c;
     int x, y, y1;
 
+    if (!qemu_console_is_visible(s)) {
+        return;
+    }
+
     if (s->ds->have_text) {
         s->text_x[0] = 0;
         s->text_y[0] = 0;
@@ -557,23 +566,25 @@ static void console_refresh(QemuConsole *s)
         s->cursor_invalidate = 1;
     }
 
-    vga_fill_rect(s, 0, 0, surface_width(surface), surface_height(surface),
+    if (s->ds->have_gfx) {
-                  color_table_rgb[0][COLOR_BLACK]);
+        vga_fill_rect(s, 0, 0, surface_width(surface), surface_height(surface),
-    y1 = s->y_displayed;
+                      color_table_rgb[0][COLOR_BLACK]);
-    for (y = 0; y < s->height; y++) {
+        y1 = s->y_displayed;
-        c = s->cells + y1 * s->width;
+        for (y = 0; y < s->height; y++) {
-        for (x = 0; x < s->width; x++) {
+            c = s->cells + y1 * s->width;
-            vga_putcharxy(s, x, y, c->ch,
+            for (x = 0; x < s->width; x++) {
-                          &(c->t_attrib));
+                vga_putcharxy(s, x, y, c->ch,
-            c++;
+                              &(c->t_attrib));
-        }
+                c++;
-        if (++y1 == s->total_height) {
+            }
-            y1 = 0;
+            if (++y1 == s->total_height) {
+                y1 = 0;
+            }
         }
+        console_show_cursor(s, 1);
+        dpy_gfx_update(s, 0, 0,
+                       surface_width(surface), surface_height(surface));
     }
-    console_show_cursor(s, 1);
-    dpy_gfx_update(s, 0, 0,
-                   surface_width(surface), surface_height(surface));
 }
 
 static void console_scroll(QemuConsole *s, int ydelta)
@@ -629,7 +640,7 @@ static void console_put_lf(QemuConsole *s)
             c->t_attrib = s->t_attrib_default;
             c++;
         }
-        if (s->y_displayed == s->y_base) {
+        if (qemu_console_is_visible(s) && s->y_displayed == s->y_base) {
             if (s->ds->have_text) {
                 s->text_x[0] = 0;
                 s->text_y[0] = 0;
@@ -637,16 +648,18 @@ static void console_put_lf(QemuConsole *s)
                 s->text_y[1] = s->height - 1;
             }
 
-            vga_bitblt(s, 0, FONT_HEIGHT, 0, 0,
+            if (s->ds->have_gfx) {
-                       s->width * FONT_WIDTH,
+                vga_bitblt(s, 0, FONT_HEIGHT, 0, 0,
-                       (s->height - 1) * FONT_HEIGHT);
+                           s->width * FONT_WIDTH,
-            vga_fill_rect(s, 0, (s->height - 1) * FONT_HEIGHT,
+                           (s->height - 1) * FONT_HEIGHT);
-                          s->width * FONT_WIDTH, FONT_HEIGHT,
+                vga_fill_rect(s, 0, (s->height - 1) * FONT_HEIGHT,
-                          color_table_rgb[0][s->t_attrib_default.bgcol]);
+                              s->width * FONT_WIDTH, FONT_HEIGHT,
-            s->update_x0 = 0;
+                              color_table_rgb[0][s->t_attrib_default.bgcol]);
-            s->update_y0 = 0;
+                s->update_x0 = 0;
-            s->update_x1 = s->width * FONT_WIDTH;
+                s->update_y0 = 0;
-            s->update_y1 = s->height * FONT_HEIGHT;
+                s->update_x1 = s->width * FONT_WIDTH;
+                s->update_y1 = s->height * FONT_HEIGHT;
+            }
         }
     }
 }
@@ -991,6 +1004,9 @@ void console_select(unsigned int index)
     if (s) {
         DisplayState *ds = s->ds;
 
+        if (active_console && active_console->cursor_timer) {
+            timer_del(active_console->cursor_timer);
+        }
         active_console = s;
         if (ds->have_gfx) {
             QLIST_FOREACH(dcl, &ds->listeners, next) {
@@ -1007,7 +1023,10 @@ void console_select(unsigned int index)
         if (ds->have_text) {
             dpy_text_resize(s, s->width, s->height);
         }
-        text_console_update_cursor(NULL);
+        if (s->cursor_timer) {
+            timer_mod(s->cursor_timer,
+                   qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + CONSOLE_CURSOR_PERIOD / 2);
+        }
     }
 }
 
@@ -1056,11 +1075,13 @@ static void kbd_send_chars(void *opaque)
 }
 
 /* called when an ascii key is pressed */
-void kbd_put_keysym_console(QemuConsole *s, int keysym)
+void kbd_put_keysym(int keysym)
 {
+    QemuConsole *s;
     uint8_t buf[16], *q;
     int c;
 
+    s = active_console;
     if (!s || (s->console_type == GRAPHIC_CONSOLE))
         return;
 
@@ -1109,11 +1130,6 @@ void kbd_put_keysym_console(QemuConsole *s, int keysym)
     }
 }
 
-void kbd_put_keysym(int keysym)
-{
-    kbd_put_keysym_console(active_console, keysym);
-}
-
 static void text_console_invalidate(void *opaque)
 {
     QemuConsole *s = (QemuConsole *) opaque;
@@ -1151,9 +1167,9 @@ static void text_console_update(void *opaque, console_ch_t *chardata)
     }
 }
 
-static QemuConsole *new_console(DisplayState *ds, console_type_t console_type,
+static QemuConsole *new_console(DisplayState *ds, console_type_t console_type)
-                                uint32_t head)
 {
+    Error *local_err = NULL;
     Object *obj;
     QemuConsole *s;
     int i;
@@ -1163,14 +1179,13 @@ static QemuConsole *new_console(DisplayState *ds, console_type_t console_type,
 
     obj = object_new(TYPE_QEMU_CONSOLE);
     s = QEMU_CONSOLE(obj);
-    s->head = head;
     object_property_add_link(obj, "device", TYPE_DEVICE,
                              (Object **)&s->device,
                              object_property_allow_set_link,
                              OBJ_PROP_LINK_UNREF_ON_RELEASE,
-                             &error_abort);
+                             &local_err);
     object_property_add_uint32_ptr(obj, "head",
-                                   &s->head, &error_abort);
+                                   &s->head, &local_err);
 
     if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
         (console_type == GRAPHIC_CONSOLE))) {
@@ -1255,18 +1270,19 @@ DisplaySurface *qemu_create_displaysurface_from(int width, int height, int bpp,
     return surface;
 }
 
-static DisplaySurface *qemu_create_message_surface(int w, int h,
+static DisplaySurface *qemu_create_dummy_surface(void)
-                                                   const char *msg)
 {
-    DisplaySurface *surface = qemu_create_displaysurface(w, h);
+    static const char msg[] =
+        "This VM has no graphic display device.";
+    DisplaySurface *surface = qemu_create_displaysurface(640, 480);
     pixman_color_t bg = color_table_rgb[0][COLOR_BLACK];
     pixman_color_t fg = color_table_rgb[0][COLOR_WHITE];
     pixman_image_t *glyph;
     int len, x, y, i;
 
     len = strlen(msg);
-    x = (w / FONT_WIDTH  - len) / 2;
+    x = (640/FONT_WIDTH  - len) / 2;
-    y = (h / FONT_HEIGHT - 1)   / 2;
+    y = (480/FONT_HEIGHT - 1)   / 2;
     for (i = 0; i < len; i++) {
         glyph = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, msg[i]);
         qemu_pixman_glyph_render(glyph, surface->image, &fg, &bg,
@@ -1288,8 +1304,6 @@ void qemu_free_displaysurface(DisplaySurface *surface)
 
 void register_displaychangelistener(DisplayChangeListener *dcl)
 {
-    static const char nodev[] =
-        "This VM has no graphic display device.";
     static DisplaySurface *dummy;
     QemuConsole *con;
 
@@ -1308,12 +1322,11 @@ void register_displaychangelistener(DisplayChangeListener *dcl)
             dcl->ops->dpy_gfx_switch(dcl, con->surface);
         } else {
             if (!dummy) {
-                dummy = qemu_create_message_surface(640, 480, nodev);
+                dummy = qemu_create_dummy_surface();
             }
             dcl->ops->dpy_gfx_switch(dcl, dummy);
         }
     }
-    text_console_update_cursor(NULL);
 }
 
 void update_displaychangelistener(DisplayChangeListener *dcl,
@@ -1537,8 +1550,6 @@ static DisplayState *get_alloc_displaystate(void)
 {
     if (!display_state) {
         display_state = g_new0(DisplayState, 1);
-        cursor_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
-                                    text_console_update_cursor, NULL);
     }
     return display_state;
 }
@@ -1549,6 +1560,7 @@ static DisplayState *get_alloc_displaystate(void)
  */
 DisplayState *init_displaystate(void)
 {
+    Error *local_err = NULL;
     gchar *name;
     int i;
 
@@ -1567,7 +1579,7 @@ DisplayState *init_displaystate(void)
          * doesn't change any more */
         name = g_strdup_printf("console[%d]", i);
         object_property_add_child(container_get(object_get_root(), "/backend"),
-                                  name, OBJECT(consoles[i]), &error_abort);
+                                  name, OBJECT(consoles[i]), &local_err);
         g_free(name);
     }
 
@@ -1578,8 +1590,7 @@ QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
                                   const GraphicHwOps *hw_ops,
                                   void *opaque)
 {
-    static const char noinit[] =
+    Error *local_err = NULL;
-        "Guest has not initialized the display (yet).";
     int width = 640;
     int height = 480;
     QemuConsole *s;
@@ -1587,15 +1598,17 @@ QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
 
     ds = get_alloc_displaystate();
     trace_console_gfx_new();
-    s = new_console(ds, GRAPHIC_CONSOLE, head);
+    s = new_console(ds, GRAPHIC_CONSOLE);
     s->hw_ops = hw_ops;
     s->hw = opaque;
     if (dev) {
-        object_property_set_link(OBJECT(s), OBJECT(dev), "device",
+        object_property_set_link(OBJECT(s), OBJECT(dev),
-                                 &error_abort);
+                                 "device", &local_err);
+        object_property_set_int(OBJECT(s), head,
+                                "head", &local_err);
     }
 
-    s->surface = qemu_create_message_surface(width, height, noinit);
+    s->surface = qemu_create_displaysurface(width, height);
     return s;
 }
 
@@ -1609,6 +1622,7 @@ QemuConsole *qemu_console_lookup_by_index(unsigned int index)
 
 QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head)
 {
+    Error *local_err = NULL;
     Object *obj;
     uint32_t h;
     int i;
@@ -1618,12 +1632,12 @@ QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head)
             continue;
         }
         obj = object_property_get_link(OBJECT(consoles[i]),
-                                       "device", &error_abort);
+                                       "device", &local_err);
         if (DEVICE(obj) != dev) {
             continue;
         }
         h = object_property_get_int(OBJECT(consoles[i]),
-                                    "head", &error_abort);
+                                    "head", &local_err);
         if (h != head) {
             continue;
         }
@@ -1698,32 +1712,14 @@ static void text_console_set_echo(CharDriverState *chr, bool echo)
     s->echo = echo;
 }
 
-static void text_console_update_cursor_timer(void)
-{
-    timer_mod(cursor_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
-              + CONSOLE_CURSOR_PERIOD / 2);
-}
-
 static void text_console_update_cursor(void *opaque)
 {
-    QemuConsole *s;
+    QemuConsole *s = opaque;
-    int i, count = 0;
 
-    cursor_visible_phase = !cursor_visible_phase;
+    s->cursor_visible_phase = !s->cursor_visible_phase;
-
+    graphic_hw_invalidate(s);
-    for (i = 0; i < nb_consoles; i++) {
+    timer_mod(s->cursor_timer,
-        s = consoles[i];
+                   qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + CONSOLE_CURSOR_PERIOD / 2);
-        if (qemu_console_is_graphic(s) ||
-            !qemu_console_is_visible(s)) {
-            continue;
-        }
-        count++;
-        graphic_hw_invalidate(s);
-    }
-
-    if (count) {
-        text_console_update_cursor_timer();
-    }
 }
 
 static const GraphicHwOps text_console_ops = {
@@ -1759,6 +1755,9 @@ static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
         s->surface = qemu_create_displaysurface(g_width, g_height);
     }
 
+    s->cursor_timer =
+        timer_new_ms(QEMU_CLOCK_REALTIME, text_console_update_cursor, s);
+
     s->hw_ops = &text_console_ops;
     s->hw = s;
 
@@ -1812,9 +1811,9 @@ static CharDriverState *text_console_init(ChardevVC *vc)
 
     trace_console_txt_new(width, height);
     if (width == 0 || height == 0) {
-        s = new_console(NULL, TEXT_CONSOLE, 0);
+        s = new_console(NULL, TEXT_CONSOLE);
     } else {
-        s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE, 0);
+        s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE);
         s->surface = qemu_create_displaysurface(width, height);
     }