Merge remote-tracking branch 'remotes/kraxel/tags/pull-vnc-20160803-1' into staging

[qemu.git] / ui / sdl.c

diff --git a/ui/sdl.c b/ui/sdl.c
index bcbf89daeb698f69bff33e2394f59a5b020f3fac..d8cf5bcf740317a5675bbb4b09fe463af3e0c27c 100644 (file)
--- a/ui/sdl.c
+++ b/ui/sdl.c
@@ -25,16 +25,20 @@
 /* Avoid compiler warning because macro is redefined in SDL_syswm.h. */
 #undef WIN32_LEAN_AND_MEAN
 
 /* Avoid compiler warning because macro is redefined in SDL_syswm.h. */
 #undef WIN32_LEAN_AND_MEAN
 

+#include "qemu/osdep.h"

 #include <SDL.h>
 #include <SDL_syswm.h>
 
 #include "qemu-common.h"
 #include <SDL.h>
 #include <SDL_syswm.h>
 
 #include "qemu-common.h"

+#include "qemu/cutils.h"

 #include "ui/console.h"
 #include "ui/console.h"

-#include "sysemu.h"
+#include "ui/input.h"
+#include "sysemu/sysemu.h"

 #include "x_keymap.h"
 #include "sdl_zoom.h"
 
 static DisplayChangeListener *dcl;
 #include "x_keymap.h"
 #include "sdl_zoom.h"
 
 static DisplayChangeListener *dcl;

+static DisplaySurface *surface;

 static SDL_Surface *real_screen;
 static SDL_Surface *guest_screen = NULL;
 static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
 static SDL_Surface *real_screen;
 static SDL_Surface *guest_screen = NULL;
 static int gui_grab; /* if true, all keyboard/mouse events are grabbed */


@@ -58,16 +62,30 @@ static SDL_Cursor *guest_sprite = NULL;
 static SDL_PixelFormat host_format;
 static int scaling_active = 0;
 static Notifier mouse_mode_notifier;
 static SDL_PixelFormat host_format;
 static int scaling_active = 0;
 static Notifier mouse_mode_notifier;

+static int idle_counter;

 
 

-static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
+#define SDL_REFRESH_INTERVAL_BUSY 10
+#define SDL_MAX_IDLE_COUNT (2 * GUI_REFRESH_INTERVAL_DEFAULT \
+                            / SDL_REFRESH_INTERVAL_BUSY + 1)
+
+#if 0
+#define DEBUG_SDL
+#endif
+
+static void sdl_update(DisplayChangeListener *dcl,
+                       int x, int y, int w, int h)

 {
 {

-    //    printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);

     SDL_Rect rec;
     rec.x = x;
     rec.y = y;
     rec.w = w;
     rec.h = h;
 
     SDL_Rect rec;
     rec.x = x;
     rec.y = y;
     rec.w = w;
     rec.h = h;
 

+#ifdef DEBUG_SDL
+    printf("SDL: Updating x=%d y=%d w=%d h=%d (scaling: %d)\n",
+           x, y, w, h, scaling_active);
+#endif
+

     if (guest_screen) {
         if (!scaling_active) {
             SDL_BlitSurface(guest_screen, &rec, real_screen, &rec);
     if (guest_screen) {
         if (!scaling_active) {
             SDL_BlitSurface(guest_screen, &rec, real_screen, &rec);


@@ -81,21 +99,14 @@ static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
     SDL_UpdateRect(real_screen, rec.x, rec.y, rec.w, rec.h);
 }
 
     SDL_UpdateRect(real_screen, rec.x, rec.y, rec.w, rec.h);
 }
 

-static void sdl_setdata(DisplayState *ds)
-{
-    if (guest_screen != NULL) SDL_FreeSurface(guest_screen);
-
-    guest_screen = SDL_CreateRGBSurfaceFrom(ds_get_data(ds), ds_get_width(ds), ds_get_height(ds),
-                                            ds_get_bits_per_pixel(ds), ds_get_linesize(ds),
-                                            ds->surface->pf.rmask, ds->surface->pf.gmask,
-                                            ds->surface->pf.bmask, ds->surface->pf.amask);
-}
-

 static void do_sdl_resize(int width, int height, int bpp)
 {
     int flags;
 static void do_sdl_resize(int width, int height, int bpp)
 {
     int flags;

+    SDL_Surface *tmp_screen;

 
 

-    //    printf("resizing to %d %d\n", w, h);
+#ifdef DEBUG_SDL
+    printf("SDL: Resizing to %dx%d bpp %d\n", width, height, bpp);
+#endif

 
     flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
     if (gui_fullscreen) {
 
     flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL;
     if (gui_fullscreen) {


@@ -106,23 +117,75 @@ static void do_sdl_resize(int width, int height, int bpp)
     if (gui_noframe)
         flags |= SDL_NOFRAME;
 
     if (gui_noframe)
         flags |= SDL_NOFRAME;
 

-    real_screen = SDL_SetVideoMode(width, height, bpp, flags);
+    tmp_screen = SDL_SetVideoMode(width, height, bpp, flags);

     if (!real_screen) {
     if (!real_screen) {

-       fprintf(stderr, "Could not open SDL display (%dx%dx%d): %s\n", width, 
-               height, bpp, SDL_GetError());
-        exit(1);
+        if (!tmp_screen) {
+            fprintf(stderr, "Could not open SDL display (%dx%dx%d): %s\n",
+                    width, height, bpp, SDL_GetError());
+            exit(1);
+        }
+    } else {
+        /*
+         * Revert to the previous video mode if the change of resizing or
+         * resolution failed.
+         */
+        if (!tmp_screen) {
+            fprintf(stderr, "Failed to set SDL display (%dx%dx%d): %s\n",
+                    width, height, bpp, SDL_GetError());
+            return;
+        }

     }
     }

+
+    real_screen = tmp_screen;

 }
 
 }
 

-static void sdl_resize(DisplayState *ds)
+static void sdl_switch(DisplayChangeListener *dcl,
+                       DisplaySurface *new_surface)

 {
 {

+    PixelFormat pf;
+
+    /* temporary hack: allows to call sdl_switch to handle scaling changes */
+    if (new_surface) {
+        surface = new_surface;
+    }
+    pf = qemu_pixelformat_from_pixman(surface->format);
+

     if (!scaling_active) {
     if (!scaling_active) {

-        do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
-    } else if (real_screen->format->BitsPerPixel != ds_get_bits_per_pixel(ds)) {
+        do_sdl_resize(surface_width(surface), surface_height(surface), 0);
+    } else if (real_screen->format->BitsPerPixel !=
+               surface_bits_per_pixel(surface)) {

         do_sdl_resize(real_screen->w, real_screen->h,
         do_sdl_resize(real_screen->w, real_screen->h,

-                      ds_get_bits_per_pixel(ds));
+                      surface_bits_per_pixel(surface));
+    }
+
+    if (guest_screen != NULL) {
+        SDL_FreeSurface(guest_screen);

     }
     }

-    sdl_setdata(ds);
+
+#ifdef DEBUG_SDL
+    printf("SDL: Creating surface with masks: %08x %08x %08x %08x\n",
+           pf.rmask, pf.gmask, pf.bmask, pf.amask);
+#endif
+
+    guest_screen = SDL_CreateRGBSurfaceFrom
+        (surface_data(surface),
+         surface_width(surface), surface_height(surface),
+         surface_bits_per_pixel(surface), surface_stride(surface),
+         pf.rmask, pf.gmask,
+         pf.bmask, pf.amask);
+}
+
+static bool sdl_check_format(DisplayChangeListener *dcl,
+                             pixman_format_code_t format)
+{
+    /*
+     * We let SDL convert for us a few more formats than,
+     * the native ones. Thes are the ones I have tested.
+     */
+    return (format == PIXMAN_x8r8g8b8 ||
+            format == PIXMAN_b8g8r8x8 ||
+            format == PIXMAN_x1r5g5b5 ||
+            format == PIXMAN_r5g6b5);

 }
 
 /* generic keyboard conversion */
 }
 
 /* generic keyboard conversion */


@@ -237,9 +300,7 @@ static void reset_keys(void)
     int i;
     for(i = 0; i < 256; i++) {
         if (modifiers_state[i]) {
     int i;
     for(i = 0; i < 256; i++) {
         if (modifiers_state[i]) {

-            if (i & SCANCODE_GREY)
-                kbd_put_keycode(SCANCODE_EMUL0);
-            kbd_put_keycode(i | SCANCODE_UP);
+            qemu_input_event_send_key_number(dcl->con, i, false);

             modifiers_state[i] = 0;
         }
     }
             modifiers_state[i] = 0;
         }
     }


@@ -247,16 +308,12 @@ static void reset_keys(void)
 
 static void sdl_process_key(SDL_KeyboardEvent *ev)
 {
 
 static void sdl_process_key(SDL_KeyboardEvent *ev)
 {

-    int keycode, v;
+    int keycode;

 
     if (ev->keysym.sym == SDLK_PAUSE) {
         /* specific case */
 
     if (ev->keysym.sym == SDLK_PAUSE) {
         /* specific case */

-        v = 0;
-        if (ev->type == SDL_KEYUP)
-            v |= SCANCODE_UP;
-        kbd_put_keycode(0xe1);
-        kbd_put_keycode(0x1d | v);
-        kbd_put_keycode(0x45 | v);
+        qemu_input_event_send_key_qcode(dcl->con, Q_KEY_CODE_PAUSE,
+                                        ev->type == SDL_KEYDOWN);

         return;
     }
 
         return;
     }
 


@@ -288,19 +345,15 @@ static void sdl_process_key(SDL_KeyboardEvent *ev)
     case 0x45: /* num lock */
     case 0x3a: /* caps lock */
         /* SDL does not send the key up event, so we generate it */
     case 0x45: /* num lock */
     case 0x3a: /* caps lock */
         /* SDL does not send the key up event, so we generate it */

-        kbd_put_keycode(keycode);
-        kbd_put_keycode(keycode | SCANCODE_UP);
+        qemu_input_event_send_key_number(dcl->con, keycode, true);
+        qemu_input_event_send_key_number(dcl->con, keycode, false);

         return;
 #endif
     }
 
     /* now send the key code */
         return;
 #endif
     }
 
     /* now send the key code */

-    if (keycode & SCANCODE_GREY)
-        kbd_put_keycode(SCANCODE_EMUL0);
-    if (ev->type == SDL_KEYUP)
-        kbd_put_keycode(keycode | SCANCODE_UP);
-    else
-        kbd_put_keycode(keycode & SCANCODE_KEYCODEMASK);
+    qemu_input_event_send_key_number(dcl->con, keycode,
+                                     ev->type == SDL_KEYDOWN);

 }
 
 static void sdl_update_caption(void)
 }
 
 static void sdl_update_caption(void)


@@ -336,7 +389,7 @@ static void sdl_hide_cursor(void)
     if (!cursor_hide)
         return;
 
     if (!cursor_hide)
         return;
 

-    if (kbd_mouse_is_absolute()) {
+    if (qemu_input_is_absolute()) {

         SDL_ShowCursor(1);
         SDL_SetCursor(sdl_cursor_hidden);
     } else {
         SDL_ShowCursor(1);
         SDL_SetCursor(sdl_cursor_hidden);
     } else {


@@ -349,10 +402,10 @@ static void sdl_show_cursor(void)
     if (!cursor_hide)
         return;
 
     if (!cursor_hide)
         return;
 

-    if (!kbd_mouse_is_absolute() || !is_graphic_console()) {
+    if (!qemu_input_is_absolute() || !qemu_console_is_graphic(NULL)) {

         SDL_ShowCursor(1);
         if (guest_cursor &&
         SDL_ShowCursor(1);
         if (guest_cursor &&

-                (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
+                (gui_grab || qemu_input_is_absolute() || absolute_enabled))

             SDL_SetCursor(guest_sprite);
         else
             SDL_SetCursor(sdl_cursor_normal);
             SDL_SetCursor(guest_sprite);
         else
             SDL_SetCursor(sdl_cursor_normal);


@@ -371,8 +424,9 @@ static void sdl_grab_start(void)
     }
     if (guest_cursor) {
         SDL_SetCursor(guest_sprite);
     }
     if (guest_cursor) {
         SDL_SetCursor(guest_sprite);

-        if (!kbd_mouse_is_absolute() && !absolute_enabled)
+        if (!qemu_input_is_absolute() && !absolute_enabled) {

             SDL_WarpMouse(guest_x, guest_y);
             SDL_WarpMouse(guest_x, guest_y);

+        }

     } else
         sdl_hide_cursor();
     SDL_WM_GrabInput(SDL_GRAB_ON);
     } else
         sdl_hide_cursor();
     SDL_WM_GrabInput(SDL_GRAB_ON);


@@ -401,10 +455,10 @@ static void absolute_mouse_grab(void)
 
 static void sdl_mouse_mode_change(Notifier *notify, void *data)
 {
 
 static void sdl_mouse_mode_change(Notifier *notify, void *data)
 {

-    if (kbd_mouse_is_absolute()) {
+    if (qemu_input_is_absolute()) {

         if (!absolute_enabled) {
             absolute_enabled = 1;
         if (!absolute_enabled) {
             absolute_enabled = 1;

-            if (is_graphic_console()) {
+            if (qemu_console_is_graphic(NULL)) {

                 absolute_mouse_grab();
             }
         }
                 absolute_mouse_grab();
             }
         }


@@ -416,80 +470,89 @@ static void sdl_mouse_mode_change(Notifier *notify, void *data)
     }
 }
 
     }
 }
 

-static void sdl_send_mouse_event(int dx, int dy, int dz, int x, int y, int state)
+static void sdl_send_mouse_event(int dx, int dy, int x, int y, int state)

 {
 {

-    int buttons = 0;
-
-    if (state & SDL_BUTTON(SDL_BUTTON_LEFT)) {
-        buttons |= MOUSE_EVENT_LBUTTON;
-    }
-    if (state & SDL_BUTTON(SDL_BUTTON_RIGHT)) {
-        buttons |= MOUSE_EVENT_RBUTTON;
-    }
-    if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE)) {
-        buttons |= MOUSE_EVENT_MBUTTON;
+    static uint32_t bmap[INPUT_BUTTON__MAX] = {
+        [INPUT_BUTTON_LEFT]       = SDL_BUTTON(SDL_BUTTON_LEFT),
+        [INPUT_BUTTON_MIDDLE]     = SDL_BUTTON(SDL_BUTTON_MIDDLE),
+        [INPUT_BUTTON_RIGHT]      = SDL_BUTTON(SDL_BUTTON_RIGHT),
+        [INPUT_BUTTON_WHEEL_UP]   = SDL_BUTTON(SDL_BUTTON_WHEELUP),
+        [INPUT_BUTTON_WHEEL_DOWN] = SDL_BUTTON(SDL_BUTTON_WHEELDOWN),
+    };
+    static uint32_t prev_state;
+
+    if (prev_state != state) {
+        qemu_input_update_buttons(dcl->con, bmap, prev_state, state);
+        prev_state = state;

     }
 
     }
 

-    if (kbd_mouse_is_absolute()) {
-        dx = x * 0x7FFF / (real_screen->w - 1);
-        dy = y * 0x7FFF / (real_screen->h - 1);
-    } else if (guest_cursor) {
-        x -= guest_x;
-        y -= guest_y;
-        guest_x += x;
-        guest_y += y;
-        dx = x;
-        dy = y;
+    if (qemu_input_is_absolute()) {
+        qemu_input_queue_abs(dcl->con, INPUT_AXIS_X, x,
+                             real_screen->w);
+        qemu_input_queue_abs(dcl->con, INPUT_AXIS_Y, y,
+                             real_screen->h);
+    } else {
+        if (guest_cursor) {
+            x -= guest_x;
+            y -= guest_y;
+            guest_x += x;
+            guest_y += y;
+            dx = x;
+            dy = y;
+        }
+        qemu_input_queue_rel(dcl->con, INPUT_AXIS_X, dx);
+        qemu_input_queue_rel(dcl->con, INPUT_AXIS_Y, dy);

     }
     }

-
-    kbd_mouse_event(dx, dy, dz, buttons);
+    qemu_input_event_sync();

 }
 
 }
 

-static void sdl_scale(DisplayState *ds, int width, int height)
+static void sdl_scale(int width, int height)

 {
     int bpp = real_screen->format->BitsPerPixel;
 
 {
     int bpp = real_screen->format->BitsPerPixel;
 

+#ifdef DEBUG_SDL
+    printf("SDL: Scaling to %dx%d bpp %d\n", width, height, bpp);
+#endif
+

     if (bpp != 16 && bpp != 32) {
         bpp = 32;
     }
     do_sdl_resize(width, height, bpp);
     scaling_active = 1;
     if (bpp != 16 && bpp != 32) {
         bpp = 32;
     }
     do_sdl_resize(width, height, bpp);
     scaling_active = 1;

-    if (!is_buffer_shared(ds->surface)) {
-        ds->surface = qemu_resize_displaysurface(ds, ds_get_width(ds),
-                                                 ds_get_height(ds));
-        dpy_gfx_resize(ds);
-    }

 }
 
 }
 

-static void toggle_full_screen(DisplayState *ds)
+static void toggle_full_screen(void)

 {
 {

+    int width = surface_width(surface);
+    int height = surface_height(surface);
+    int bpp = surface_bits_per_pixel(surface);
+

     gui_fullscreen = !gui_fullscreen;
     if (gui_fullscreen) {
         gui_saved_width = real_screen->w;
         gui_saved_height = real_screen->h;
         gui_saved_scaling = scaling_active;
 
     gui_fullscreen = !gui_fullscreen;
     if (gui_fullscreen) {
         gui_saved_width = real_screen->w;
         gui_saved_height = real_screen->h;
         gui_saved_scaling = scaling_active;
 

-        do_sdl_resize(ds_get_width(ds), ds_get_height(ds),
-                      ds_get_bits_per_pixel(ds));
+        do_sdl_resize(width, height, bpp);

         scaling_active = 0;
 
         gui_saved_grab = gui_grab;
         sdl_grab_start();
     } else {
         if (gui_saved_scaling) {
         scaling_active = 0;
 
         gui_saved_grab = gui_grab;
         sdl_grab_start();
     } else {
         if (gui_saved_scaling) {

-            sdl_scale(ds, gui_saved_width, gui_saved_height);
+            sdl_scale(gui_saved_width, gui_saved_height);

         } else {
         } else {

-            do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
+            do_sdl_resize(width, height, 0);

         }
         }

-        if (!gui_saved_grab || !is_graphic_console()) {
+        if (!gui_saved_grab || !qemu_console_is_graphic(NULL)) {

             sdl_grab_end();
         }
     }
             sdl_grab_end();
         }
     }

-    vga_hw_invalidate();
-    vga_hw_update();
+    graphic_hw_invalidate(NULL);
+    graphic_hw_update(NULL);

 }
 
 }
 

-static void handle_keydown(DisplayState *ds, SDL_Event *ev)
+static void handle_keydown(SDL_Event *ev)

 {
     int mod_state;
     int keycode;
 {
     int mod_state;
     int keycode;


@@ -508,15 +571,15 @@ static void handle_keydown(DisplayState *ds, SDL_Event *ev)
         keycode = sdl_keyevent_to_keycode(&ev->key);
         switch (keycode) {
         case 0x21: /* 'f' key on US keyboard */
         keycode = sdl_keyevent_to_keycode(&ev->key);
         switch (keycode) {
         case 0x21: /* 'f' key on US keyboard */

-            toggle_full_screen(ds);
+            toggle_full_screen();

             gui_keysym = 1;
             break;
         case 0x16: /* 'u' key on US keyboard */
             if (scaling_active) {
                 scaling_active = 0;
             gui_keysym = 1;
             break;
         case 0x16: /* 'u' key on US keyboard */
             if (scaling_active) {
                 scaling_active = 0;

-                sdl_resize(ds);
-                vga_hw_invalidate();
-                vga_hw_update();
+                sdl_switch(dcl, NULL);
+                graphic_hw_invalidate(NULL);
+                graphic_hw_update(NULL);

             }
             gui_keysym = 1;
             break;
             }
             gui_keysym = 1;
             break;


@@ -528,7 +591,7 @@ static void handle_keydown(DisplayState *ds, SDL_Event *ev)
             if (gui_fullscreen) {
                 break;
             }
             if (gui_fullscreen) {
                 break;
             }

-            if (!is_graphic_console()) {
+            if (!qemu_console_is_graphic(NULL)) {

                 /* release grab if going to a text console */
                 if (gui_grab) {
                     sdl_grab_end();
                 /* release grab if going to a text console */
                 if (gui_grab) {
                     sdl_grab_end();


@@ -545,17 +608,18 @@ static void handle_keydown(DisplayState *ds, SDL_Event *ev)
             if (!gui_fullscreen) {
                 int width = MAX(real_screen->w + (keycode == 0x1b ? 50 : -50),
                                 160);
             if (!gui_fullscreen) {
                 int width = MAX(real_screen->w + (keycode == 0x1b ? 50 : -50),
                                 160);

-                int height = (ds_get_height(ds) * width) / ds_get_width(ds);
+                int height = (surface_height(surface) * width) /
+                    surface_width(surface);

 
 

-                sdl_scale(ds, width, height);
-                vga_hw_invalidate();
-                vga_hw_update();
+                sdl_scale(width, height);
+                graphic_hw_invalidate(NULL);
+                graphic_hw_update(NULL);

                 gui_keysym = 1;
             }
         default:
             break;
         }
                 gui_keysym = 1;
             }
         default:
             break;
         }

-    } else if (!is_graphic_console()) {
+    } else if (!qemu_console_is_graphic(NULL)) {

         int keysym = 0;
 
         if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
         int keysym = 0;
 
         if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {


@@ -629,12 +693,12 @@ static void handle_keydown(DisplayState *ds, SDL_Event *ev)
             kbd_put_keysym(ev->key.keysym.unicode);
         }
     }
             kbd_put_keysym(ev->key.keysym.unicode);
         }
     }

-    if (is_graphic_console() && !gui_keysym) {
+    if (qemu_console_is_graphic(NULL) && !gui_keysym) {

         sdl_process_key(&ev->key);
     }
 }
 
         sdl_process_key(&ev->key);
     }
 }
 

-static void handle_keyup(DisplayState *ds, SDL_Event *ev)
+static void handle_keyup(SDL_Event *ev)

 {
     int mod_state;
 
 {
     int mod_state;
 


@@ -648,7 +712,7 @@ static void handle_keyup(DisplayState *ds, SDL_Event *ev)
         if (gui_keysym == 0) {
             /* exit/enter grab if pressing Ctrl-Alt */
             if (!gui_grab) {
         if (gui_keysym == 0) {
             /* exit/enter grab if pressing Ctrl-Alt */
             if (!gui_grab) {

-                if (is_graphic_console()) {
+                if (qemu_console_is_graphic(NULL)) {

                     sdl_grab_start();
                 }
             } else if (!gui_fullscreen) {
                     sdl_grab_start();
                 }
             } else if (!gui_fullscreen) {


@@ -661,17 +725,17 @@ static void handle_keyup(DisplayState *ds, SDL_Event *ev)
         }
         gui_keysym = 0;
     }
         }
         gui_keysym = 0;
     }

-    if (is_graphic_console() && !gui_keysym) {
+    if (qemu_console_is_graphic(NULL) && !gui_keysym) {

         sdl_process_key(&ev->key);
     }
 }
 
         sdl_process_key(&ev->key);
     }
 }
 

-static void handle_mousemotion(DisplayState *ds, SDL_Event *ev)
+static void handle_mousemotion(SDL_Event *ev)

 {
     int max_x, max_y;
 
 {
     int max_x, max_y;
 

-    if (is_graphic_console() &&
-        (kbd_mouse_is_absolute() || absolute_enabled)) {
+    if (qemu_console_is_graphic(NULL) &&
+        (qemu_input_is_absolute() || absolute_enabled)) {

         max_x = real_screen->w - 1;
         max_y = real_screen->h - 1;
         if (gui_grab && (ev->motion.x == 0 || ev->motion.y == 0 ||
         max_x = real_screen->w - 1;
         max_y = real_screen->h - 1;
         if (gui_grab && (ev->motion.x == 0 || ev->motion.y == 0 ||


@@ -684,49 +748,38 @@ static void handle_mousemotion(DisplayState *ds, SDL_Event *ev)
             sdl_grab_start();
         }
     }
             sdl_grab_start();
         }
     }

-    if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
-        sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,
+    if (gui_grab || qemu_input_is_absolute() || absolute_enabled) {
+        sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel,

                              ev->motion.x, ev->motion.y, ev->motion.state);
     }
 }
 
                              ev->motion.x, ev->motion.y, ev->motion.state);
     }
 }
 

-static void handle_mousebutton(DisplayState *ds, SDL_Event *ev)
+static void handle_mousebutton(SDL_Event *ev)

 {
     int buttonstate = SDL_GetMouseState(NULL, NULL);
     SDL_MouseButtonEvent *bev;
 {
     int buttonstate = SDL_GetMouseState(NULL, NULL);
     SDL_MouseButtonEvent *bev;

-    int dz;

 
 

-    if (!is_graphic_console()) {
+    if (!qemu_console_is_graphic(NULL)) {

         return;
     }
 
     bev = &ev->button;
         return;
     }
 
     bev = &ev->button;

-    if (!gui_grab && !kbd_mouse_is_absolute()) {
+    if (!gui_grab && !qemu_input_is_absolute()) {

         if (ev->type == SDL_MOUSEBUTTONUP && bev->button == SDL_BUTTON_LEFT) {
             /* start grabbing all events */
             sdl_grab_start();
         }
     } else {
         if (ev->type == SDL_MOUSEBUTTONUP && bev->button == SDL_BUTTON_LEFT) {
             /* start grabbing all events */
             sdl_grab_start();
         }
     } else {

-        dz = 0;

         if (ev->type == SDL_MOUSEBUTTONDOWN) {
             buttonstate |= SDL_BUTTON(bev->button);
         } else {
             buttonstate &= ~SDL_BUTTON(bev->button);
         }
         if (ev->type == SDL_MOUSEBUTTONDOWN) {
             buttonstate |= SDL_BUTTON(bev->button);
         } else {
             buttonstate &= ~SDL_BUTTON(bev->button);
         }

-#ifdef SDL_BUTTON_WHEELUP
-        if (bev->button == SDL_BUTTON_WHEELUP &&
-            ev->type == SDL_MOUSEBUTTONDOWN) {
-            dz = -1;
-        } else if (bev->button == SDL_BUTTON_WHEELDOWN &&
-                   ev->type == SDL_MOUSEBUTTONDOWN) {
-            dz = 1;
-        }
-#endif
-        sdl_send_mouse_event(0, 0, dz, bev->x, bev->y, buttonstate);
+        sdl_send_mouse_event(0, 0, bev->x, bev->y, buttonstate);

     }
 }
 
     }
 }
 

-static void handle_activation(DisplayState *ds, SDL_Event *ev)
+static void handle_activation(SDL_Event *ev)

 {
 #ifdef _WIN32
     /* Disable grab if the window no longer has the focus
 {
 #ifdef _WIN32
     /* Disable grab if the window no longer has the focus


@@ -736,45 +789,48 @@ static void handle_activation(DisplayState *ds, SDL_Event *ev)
         sdl_grab_end();
     }
 #endif
         sdl_grab_end();
     }
 #endif

-    if (!gui_grab && ev->active.gain && is_graphic_console() &&
-        (kbd_mouse_is_absolute() || absolute_enabled)) {
+    if (!gui_grab && ev->active.gain && qemu_console_is_graphic(NULL) &&
+        (qemu_input_is_absolute() || absolute_enabled)) {

         absolute_mouse_grab();
     }
     if (ev->active.state & SDL_APPACTIVE) {
         if (ev->active.gain) {
             /* Back to default interval */
         absolute_mouse_grab();
     }
     if (ev->active.state & SDL_APPACTIVE) {
         if (ev->active.gain) {
             /* Back to default interval */

-            dcl->gui_timer_interval = 0;
-            dcl->idle = 0;
+            update_displaychangelistener(dcl, GUI_REFRESH_INTERVAL_DEFAULT);

         } else {
         } else {

-            /* Sleeping interval */
-            dcl->gui_timer_interval = 500;
-            dcl->idle = 1;
+            /* Sleeping interval.  Not using the long default here as
+             * sdl_refresh does not only update the guest screen, but
+             * also checks for gui events. */
+            update_displaychangelistener(dcl, 500);

         }
     }
 }
 
         }
     }
 }
 

-static void sdl_refresh(DisplayState *ds)
+static void sdl_refresh(DisplayChangeListener *dcl)

 {
     SDL_Event ev1, *ev = &ev1;
 {
     SDL_Event ev1, *ev = &ev1;

+    int idle = 1;

 
     if (last_vm_running != runstate_is_running()) {
         last_vm_running = runstate_is_running();
         sdl_update_caption();
     }
 
 
     if (last_vm_running != runstate_is_running()) {
         last_vm_running = runstate_is_running();
         sdl_update_caption();
     }
 

-    vga_hw_update();
-    SDL_EnableUNICODE(!is_graphic_console());
+    graphic_hw_update(NULL);
+    SDL_EnableUNICODE(!qemu_console_is_graphic(NULL));

 
     while (SDL_PollEvent(ev)) {
         switch (ev->type) {
         case SDL_VIDEOEXPOSE:
 
     while (SDL_PollEvent(ev)) {
         switch (ev->type) {
         case SDL_VIDEOEXPOSE:

-            sdl_update(ds, 0, 0, real_screen->w, real_screen->h);
+            sdl_update(dcl, 0, 0, real_screen->w, real_screen->h);

             break;
         case SDL_KEYDOWN:
             break;
         case SDL_KEYDOWN:

-            handle_keydown(ds, ev);
+            idle = 0;
+            handle_keydown(ev);

             break;
         case SDL_KEYUP:
             break;
         case SDL_KEYUP:

-            handle_keyup(ds, ev);
+            idle = 0;
+            handle_keyup(ev);

             break;
         case SDL_QUIT:
             if (!no_quit) {
             break;
         case SDL_QUIT:
             if (!no_quit) {


@@ -783,35 +839,51 @@ static void sdl_refresh(DisplayState *ds)
             }
             break;
         case SDL_MOUSEMOTION:
             }
             break;
         case SDL_MOUSEMOTION:

-            handle_mousemotion(ds, ev);
+            idle = 0;
+            handle_mousemotion(ev);

             break;
         case SDL_MOUSEBUTTONDOWN:
         case SDL_MOUSEBUTTONUP:
             break;
         case SDL_MOUSEBUTTONDOWN:
         case SDL_MOUSEBUTTONUP:

-            handle_mousebutton(ds, ev);
+            idle = 0;
+            handle_mousebutton(ev);

             break;
         case SDL_ACTIVEEVENT:
             break;
         case SDL_ACTIVEEVENT:

-            handle_activation(ds, ev);
+            handle_activation(ev);

             break;
         case SDL_VIDEORESIZE:
             break;
         case SDL_VIDEORESIZE:

-            sdl_scale(ds, ev->resize.w, ev->resize.h);
-            vga_hw_invalidate();
-            vga_hw_update();
+            sdl_scale(ev->resize.w, ev->resize.h);
+            graphic_hw_invalidate(NULL);
+            graphic_hw_update(NULL);

             break;
         default:
             break;
         }
     }
             break;
         default:
             break;
         }
     }

+
+    if (idle) {
+        if (idle_counter < SDL_MAX_IDLE_COUNT) {
+            idle_counter++;
+            if (idle_counter >= SDL_MAX_IDLE_COUNT) {
+                dcl->update_interval = GUI_REFRESH_INTERVAL_DEFAULT;
+            }
+        }
+    } else {
+        idle_counter = 0;
+        dcl->update_interval = SDL_REFRESH_INTERVAL_BUSY;
+    }

 }
 
 }
 

-static void sdl_mouse_warp(DisplayState *ds, int x, int y, int on)
+static void sdl_mouse_warp(DisplayChangeListener *dcl,
+                           int x, int y, int on)

 {
     if (on) {
         if (!guest_cursor)
             sdl_show_cursor();
 {
     if (on) {
         if (!guest_cursor)
             sdl_show_cursor();

-        if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
+        if (gui_grab || qemu_input_is_absolute() || absolute_enabled) {

             SDL_SetCursor(guest_sprite);
             SDL_SetCursor(guest_sprite);

-            if (!kbd_mouse_is_absolute() && !absolute_enabled)
+            if (!qemu_input_is_absolute() && !absolute_enabled) {

                 SDL_WarpMouse(x, y);
                 SDL_WarpMouse(x, y);

+            }

         }
     } else if (gui_grab)
         sdl_hide_cursor();
         }
     } else if (gui_grab)
         sdl_hide_cursor();


@@ -819,7 +891,8 @@ static void sdl_mouse_warp(DisplayState *ds, int x, int y, int on)
     guest_x = x, guest_y = y;
 }
 
     guest_x = x, guest_y = y;
 }
 

-static void sdl_mouse_define(DisplayState *ds, QEMUCursor *c)
+static void sdl_mouse_define(DisplayChangeListener *dcl,
+                             QEMUCursor *c)

 {
     uint8_t *image, *mask;
     int bpl;
 {
     uint8_t *image, *mask;
     int bpl;


@@ -838,7 +911,7 @@ static void sdl_mouse_define(DisplayState *ds, QEMUCursor *c)
     g_free(mask);
 
     if (guest_cursor &&
     g_free(mask);
 
     if (guest_cursor &&

-            (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
+            (gui_grab || qemu_input_is_absolute() || absolute_enabled))

         SDL_SetCursor(guest_sprite);
 }
 
         SDL_SetCursor(guest_sprite);
 }
 


@@ -849,6 +922,26 @@ static void sdl_cleanup(void)
     SDL_QuitSubSystem(SDL_INIT_VIDEO);
 }
 
     SDL_QuitSubSystem(SDL_INIT_VIDEO);
 }
 

+static const DisplayChangeListenerOps dcl_ops = {
+    .dpy_name             = "sdl",
+    .dpy_gfx_update       = sdl_update,
+    .dpy_gfx_switch       = sdl_switch,
+    .dpy_gfx_check_format = sdl_check_format,
+    .dpy_refresh          = sdl_refresh,
+    .dpy_mouse_set        = sdl_mouse_warp,
+    .dpy_cursor_define    = sdl_mouse_define,
+};
+
+void sdl_display_early_init(int opengl)
+{
+    if (opengl == 1 /* on */) {
+        fprintf(stderr,
+                "SDL1 display code has no opengl support.\n"
+                "Please recompile qemu with SDL2, using\n"
+                "./configure --enable-sdl --with-sdlabi=2.0\n");
+    }
+}
+

 void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
 {
     int flags;
 void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
 {
     int flags;


@@ -916,14 +1009,9 @@ void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
         sdl_grab_start();
     }
 
         sdl_grab_start();
     }
 

-    dcl = g_malloc0(sizeof(DisplayChangeListener));
-    dcl->dpy_gfx_update = sdl_update;
-    dcl->dpy_gfx_resize = sdl_resize;
-    dcl->dpy_refresh = sdl_refresh;
-    dcl->dpy_gfx_setdata = sdl_setdata;
-    dcl->dpy_mouse_set = sdl_mouse_warp;
-    dcl->dpy_cursor_define = sdl_mouse_define;
-    register_displaychangelistener(ds, dcl);
+    dcl = g_new0(DisplayChangeListener, 1);
+    dcl->ops = &dcl_ops;
+    register_displaychangelistener(dcl);

 
     mouse_mode_notifier.notify = sdl_mouse_mode_change;
     qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier);
 
     mouse_mode_notifier.notify = sdl_mouse_mode_change;
     qemu_add_mouse_mode_change_notifier(&mouse_mode_notifier);