Commit: 68ce6f59e103467a3cf6beaee19c388b2d2f3d22 - tme (git)

Commit MetaInfo

• Révision: 68ce6f59e103467a3cf6beaee19c388b2d2f3d22 (tree)
• l'heure: 2022-08-28 20:28:50
• Auteur: phabrics <phabrics@phab...>
• Commiter: phabrics

Message de Log

Work to add SDL driver to display host framework.

Change Summary

• modified: host/display/display-keyboard.c
• modified: host/display/display-mouse.c
• modified: host/display/display.c
• modified: host/display/display.h
• modified: host/display/gtk/Makefile.am
• modified: host/display/gtk/gtk-display.h
• modified: host/display/gtk/gtk-mouse.c
• delete: host/display/gtk/{gtk-screen.c => gtk-display.c}
• modified: host/display/rfb/rfb-display.c
• add: host/display/sdl/sdl-display.c

Modification

--- a/host/display/display-keyboard.c
+++ b/host/display/display-keyboard.c
@@ -225,15 +225,37 @@ _tme_keyboard_keyval_name(tme_keyboard_keyval_t keyval)
 }
 #endif
 
-/* this is a callback for a key press or release event: */
+/* this is a generic callback for a key press or release event: */
 int
-_tme_keyboard_key_event(struct tme_keyboard_event *tme_event,
-			struct tme_display *display)
+_tme_keyboard_key_press(int down, tme_keyboard_keyval_t key, void *disp)
+{
+  struct tme_keyboard_event tme_event;
+  struct tme_display *display = (_tme_display_get) ? (_tme_display_get(disp)) : (disp);
+
+  /* make a tme event from this key event: */
+  tme_event.tme_keyboard_event_type
+    = (down
+       ? TME_KEYBOARD_EVENT_PRESS
+       : TME_KEYBOARD_EVENT_RELEASE);
+  tme_event.tme_keyboard_event_modifiers
+    = TME_KEYBOARD_MODIFIER_NONE;
+  tme_event.tme_keyboard_event_keyval
+    = key;
+  tme_event.tme_keyboard_event_time = tme_thread_get_time();
+
+  return _tme_keyboard_key_event(&tme_event, display);
+}
+
+int
+_tme_keyboard_key_event(struct tme_keyboard_event *tme_event, struct tme_display *display)
 {
   int was_empty;
   int new_callouts;
   int rc;
 
+  /* lock the mutex: */
+  tme_mutex_lock(&display->tme_display_mutex);
+
   /* assume that we won't need any new callouts: */
   new_callouts = 0;
   
@@ -264,6 +286,9 @@ _tme_keyboard_key_event(struct tme_keyboard_event *tme_event,
   /* run any callouts: */
   //_tme_display_callout(display, new_callouts);
 
+  /* unlock the mutex: */
+  tme_mutex_unlock(&display->tme_display_mutex);
+
   /* don't process this event any further: */
   return (TRUE);
 }

--- a/host/display/display-mouse.c
+++ b/host/display/display-mouse.c
@@ -52,15 +52,71 @@ _tme_mouse_debug(const struct tme_mouse_event *event)
 #define _tme_mouse_debug(e) do { } while (/* CONSTCOND */ 0)
 #endif
 
-/* this is a callback for a mouse event in the framebuffer event box: */
+/* this is a generic callback for a mouse event: */
 int
-_tme_mouse_mouse_event(struct tme_keyboard_event *tme_event,
-		       struct tme_display *display)
+_tme_mouse_button_press(int button, int x, int y, struct tme_display *display)
 {
+  int state;
+    
+  /* make the buttons mask: */
+  state = display->tme_screen_mouse_buttons_last;
+
+  if(button>0)
+    state |= TME_BIT(button-1);
+  else if(button) {
+    button = -button;
+    state &= ~TME_BIT(button-1);
+  }
+
+  return _tme_mouse_buttons_event(state, x, y, display);  
+}
+
+int _tme_mouse_buttons_event(int buttons, int x, int y, void *disp)
+{
+  struct tme_mouse_event tme_event;
   int was_empty;
-  int new_callouts;
-  int rc;
+  int new_callouts, rc;
+  struct tme_display *display = (_tme_display_get) ? (_tme_display_get(disp)) : (disp);
+  
+  /* start the tme event: */
+  tme_event.tme_mouse_event_delta_units
+    = TME_MOUSE_UNITS_UNKNOWN;
+
+  /* lock the mutex: */
+  tme_mutex_lock(&display->tme_display_mutex);
 
+  /* set the event time: */
+  tme_event.tme_mouse_event_time = tme_thread_get_time();
+
+  /* if the button mask and pointer position haven't changed, return now.
+     every time we warp the pointer we will get a motion event, and
+     this should ignore those events: */
+
+  if (buttons == display->tme_screen_mouse_buttons_last
+      && x == display->tme_screen_mouse_warp_x
+      && y == display->tme_screen_mouse_warp_y) {
+    
+    /* unlock the mutex: */
+    tme_mutex_unlock(&display->tme_display_mutex);
+    
+    /* stop propagating this event: */
+    return (TRUE);
+  }
+  
+  tme_event.tme_mouse_event_buttons =
+    display->tme_screen_mouse_buttons_last = buttons;
+  
+  /* make the deltas: */
+  tme_event.tme_mouse_event_delta_x = 
+    (((int) x)
+     - ((int) display->tme_screen_mouse_warp_x));
+  tme_event.tme_mouse_event_delta_y = 
+    (((int) y)
+     - ((int) display->tme_screen_mouse_warp_y));
+
+  display->tme_screen_mouse_warp_x = x;
+  display->tme_screen_mouse_warp_y = y;
+  
   /* assume that we won't need any new callouts: */
   new_callouts = 0;
   
@@ -69,9 +125,9 @@ _tme_mouse_mouse_event(struct tme_keyboard_event *tme_event,
     = tme_mouse_buffer_is_empty(display->tme_display_mouse_buffer);
 
   /* add this tme event to the mouse buffer: */
-  _tme_mouse_debug(tme_event);
+  _tme_mouse_debug(&tme_event);
   rc = tme_mouse_buffer_copyin(display->tme_display_mouse_buffer,
-			       tme_event);
+			       &tme_event);
   assert (rc == TME_OK);
 
   /* if the mouse buffer was empty and now it isn't,
@@ -87,6 +143,9 @@ _tme_mouse_mouse_event(struct tme_keyboard_event *tme_event,
   /* run any callouts: */
   //_tme_display_callout(display, new_callouts);
 
+  /* unlock the mutex: */
+  tme_mutex_unlock(&display->tme_display_mutex);
+
   /* don't process this event any further: */
   return (TRUE);
 }
@@ -111,8 +170,8 @@ _tme_mouse_ctrl(struct tme_mouse_connection *conn_mouse,
 /* this is called to read the mouse: */
 static int
 _tme_mouse_read(struct tme_mouse_connection *conn_mouse, 
-		    struct tme_mouse_event *event,
-		    unsigned int count)
+		struct tme_mouse_event *event,
+		unsigned int count)
 {
   struct tme_display *display;
   int rc;

--- a/host/display/display.c
+++ b/host/display/display.c
@@ -203,6 +203,8 @@ int
 tme_display_update(void *disp) {
   struct tme_display *display;
   struct tme_screen *screen;
+  struct tme_fb_connection *conn_fb;
+  int width, height;
   int rc;
   
   display = (struct tme_display *)disp;
@@ -219,6 +221,9 @@ tme_display_update(void *disp) {
     
   _tme_display_callout(display, 0);
 
+  width = screen->tme_screen_fb->tme_fb_connection_width;
+  height = screen->tme_screen_fb->tme_fb_connection_height;
+  
   /* loop over all screens: */
   for (screen = display->tme_display_screens;
        screen != NULL;
@@ -227,7 +232,7 @@ tme_display_update(void *disp) {
     switch(screen->tme_screen_update) {
     case TME_SCREEN_UPDATE_REDRAW:
       if(display->tme_screen_redraw)
-	display->tme_screen_redraw(screen);
+	display->tme_screen_redraw(screen, 0, 0, width, height);
       break;
     case TME_SCREEN_UPDATE_RESIZE:
       if(display->tme_screen_resize)
@@ -555,6 +560,9 @@ _tme_screen_add(struct tme_display *display,
   /* save our connection: */
   screen->tme_screen_fb = conn;
 
+  /* default screen scale: */
+  screen->tme_screen_scale = 1;
+  
   /* the user hasn't specified a scaling yet: */
   screen->tme_screen_fb_scale
     = -TME_FB_XLAT_SCALE_NONE;
@@ -598,7 +606,7 @@ _tme_display_connection_make(struct tme_connection *conn,
   if (state == TME_CONNECTION_FULL) {
 
     /* lock our mutex: */
-    //tme_mutex_lock(&display->tme_display_mutex);
+    tme_mutex_lock(&display->tme_display_mutex);
 
     /* if our initial screen is already connected, make a new screen: */
     screen = (display->tme_screen_add) ?
@@ -606,10 +614,10 @@ _tme_display_connection_make(struct tme_connection *conn,
       tme_screen_new(display, struct tme_screen, conn);
 
     /* unlock our mutex: */
-    //tme_mutex_unlock(&display->tme_display_mutex);
+    tme_mutex_unlock(&display->tme_display_mutex);
 
     /* call our mode change function: */
-    //    _tme_screen_mode_change((struct tme_fb_connection *) conn);
+    _tme_screen_mode_change((struct tme_fb_connection *) conn);
   }
 
   return (TME_OK);
@@ -669,9 +677,14 @@ _tme_display_connections_new(struct tme_element *element,
 int tme_display_init(struct tme_element *element,
 		     struct tme_display *display) {
 
+  if(!display) display = tme_new0(struct tme_display, 1);
+  
   /* start our data structure: */
   display->tme_display_element = element;
 
+  /* default display: */
+  _tme_display_get = 0;
+  
   /* create the keyboard: */
   _tme_keyboard_new(display);
 

--- a/host/display/display.h
+++ b/host/display/display.h
@@ -70,7 +70,7 @@ struct tme_screen {
   struct tme_display *tme_screen_display;
 
   /* the framebuffer connection.  unlike many other elements, this is
-     *our* side of the framebuffer connection, not the peer's side: */
+   *our* side of the framebuffer connection, not the peer's side: */
   struct tme_fb_connection *tme_screen_fb;
 
   /* the current scaling.  if this is < 0, the user has not forced a
@@ -152,16 +152,38 @@ struct tme_display {
   int tme_screen_width;
   int tme_screen_height;
   
+  /* screen mouse data: */
+  int tme_screen_mouse_buttons_last,
+    tme_screen_mouse_warp_x,
+    tme_screen_mouse_warp_y;
+
+  /* a convenience pointer for any platform-specific host data: */
+  void *tme_screen_data;
+  
   /* implementation-specific callback functions: */
   int (*tme_display_bell) _TME_P((struct tme_display *));
   int (*tme_display_update) _TME_P((struct tme_display *));
   struct tme_screen *(*tme_screen_add) _TME_P((struct tme_display *, struct tme_connection *));
   int (*tme_screen_resize) _TME_P((struct tme_screen *));
-  int (*tme_screen_redraw) _TME_P((struct tme_screen *));
+  int (*tme_screen_redraw) _TME_P((struct tme_screen *, int x, int y, int w, int h));
   int (*tme_screen_update) _TME_P((struct tme_screen *));
 };
 
 /* prototypes: */
+/* this recovers the scanline-pad value for an image buffer: */
+inline unsigned int
+_tme_scanline_pad(int bpl)
+{
+  if ((bpl % sizeof(tme_uint32_t)) == 0) {
+    return (32);
+  }
+  if ((bpl % sizeof(tme_uint16_t)) == 0) {
+    return (16);
+  }
+  return (8);
+}
+
+struct tme_display *(*_tme_display_get) _TME_P((void *));
 struct tme_screen *_tme_screen_add _TME_P((struct tme_display *,
 					   size_t,
 					   struct tme_connection *));
@@ -172,10 +194,12 @@ void _tme_screen_xlat_set _TME_P((struct tme_screen *screen));
 void _tme_keyboard_new _TME_P((struct tme_display *));
 int _tme_keyboard_connections_new _TME_P((struct tme_display *,
 					  struct tme_connection **));
+int _tme_keyboard_key_press _TME_P((int down, tme_keyboard_keyval_t key, void *disp));
 void _tme_mouse_new _TME_P((struct tme_display *));
 void _tme_mouse_mode_off _TME_P((struct tme_screen *, tme_uint32_t));
 int _tme_mouse_connections_new _TME_P((struct tme_display *,
 				       struct tme_connection **));
+int _tme_mouse_buttons_event _TME_P((int buttons, int x, int y, void *disp));
 
 #endif /* _HOST_DISPLAY_H */
 

--- a/host/display/gtk/Makefile.am
+++ b/host/display/gtk/Makefile.am
@@ -6,7 +6,7 @@ AUTOMAKE_OPTIONS = 1.4 gnu
 AM_CPPFLAGS = -I$(top_srcdir) -I$(srcdir) -I$(top_srcdir)/lib -I$(srcdir)/.. -I. -D_TME_IMPL $(GTK_CFLAGS)
 
 pkglib_LTLIBRARIES = tme_host_gtk.la
-tme_host_gtk_la_SOURCES = gtk-mouse.c gtk-keyboard.c gtk-screen.c gtk-display.h
+tme_host_gtk_la_SOURCES = gtk-mouse.c gtk-keyboard.c gtk-display.c gtk-display.h
 tme_host_gtk_la_LDFLAGS = -module -version-info 0:0:0
 tme_host_gtk_la_LIBADD = ../libtme-display.la $(GTK_LIBS)
 

--- a/host/display/gtk/gtk-screen.c
+++ b/host/display/gtk/gtk-display.c
@@ -52,19 +52,6 @@ _tme_gtk_display_update(struct tme_display *display) {
   return TME_OK;
 }
 
-/* this recovers the scanline-pad value for an image buffer: */
-static unsigned int
-_tme_gtk_scanline_pad(int bpl)
-{
-  if ((bpl % sizeof(tme_uint32_t)) == 0) {
-    return (32);
-  }
-  if ((bpl % sizeof(tme_uint16_t)) == 0) {
-    return (16);
-  }
-  return (8);
-}
-
 /* this sets the screen scaling to that indicated by the Scale menu: */
 static void
 _tme_gtk_screen_scale_default(GtkWidget *widget,
@@ -297,7 +284,7 @@ _tme_gtk_screen_configure(GtkWidget         *widget,
   conn_fb->tme_fb_connection_width = cairo_image_surface_get_width(screen->tme_gtk_screen_surface);
   conn_fb->tme_fb_connection_height = cairo_image_surface_get_height(screen->tme_gtk_screen_surface);
   conn_fb->tme_fb_connection_skipx = 0;
-  conn_fb->tme_fb_connection_scanline_pad = _tme_gtk_scanline_pad(cairo_image_surface_get_stride(screen->tme_gtk_screen_surface));
+  conn_fb->tme_fb_connection_scanline_pad = _tme_scanline_pad(cairo_image_surface_get_stride(screen->tme_gtk_screen_surface));
   conn_fb->tme_fb_connection_order = TME_ENDIAN_NATIVE;
   conn_fb->tme_fb_connection_buffer = cairo_image_surface_get_data(screen->tme_gtk_screen_surface);
   conn_fb->tme_fb_connection_buffsz = cairo_image_surface_get_stride(screen->tme_gtk_screen_surface) * conn_fb->tme_fb_connection_height;
@@ -317,7 +304,7 @@ _tme_gtk_screen_configure(GtkWidget         *widget,
 
 /* this is called before the screen's display is updated: */
 static void
-_tme_gtk_screen_redraw(struct tme_gtk_screen *screen)
+_tme_gtk_screen_redraw(struct tme_gtk_screen *screen, int x, int y, int w, int h)
 {
   cairo_surface_flush(screen->tme_gtk_screen_surface);
   cairo_surface_mark_dirty(screen->tme_gtk_screen_surface);
@@ -367,9 +354,6 @@ _tme_gtk_screen_new(struct tme_gdk_display *display,
   GtkWidget *menu_item;
   char title[sizeof(PACKAGE_STRING) + 16];
 
-  /* lock our mutex: */
-  tme_mutex_lock(&display->display.tme_display_mutex);
-
   screen = tme_screen_new(display, struct tme_gtk_screen, conn);
 
   screen->screen.tme_screen_scale = gdk_monitor_get_scale_factor(display->tme_gdk_display_monitor);
@@ -455,14 +439,15 @@ _tme_gtk_screen_new(struct tme_gdk_display *display,
   snprintf(title, sizeof(title), "%s (%s)", PACKAGE_STRING, conn->tme_connection_other->tme_connection_element->tme_element_args[0]);
   gtk_window_set_title(GTK_WINDOW(screen->tme_gtk_screen_window), title);
 
-  _tme_gtk_screen_resize(screen);
-  
   /* unlock our mutex: */
   tme_mutex_unlock(&display->display.tme_display_mutex);
 
   /* show the top-level window: */
   gtk_widget_show_all(screen->tme_gtk_screen_window);
 
+  /* lock our mutex: */
+  tme_mutex_lock(&display->display.tme_display_mutex);
+
   return (screen);
 }
 

--- a/host/display/gtk/gtk-display.h
+++ b/host/display/gtk/gtk-display.h
@@ -97,12 +97,6 @@ struct tme_gtk_screen {
      for the framebuffer event box: */
   GdkEventMask tme_gtk_screen_mouse_events_old;
 
-  /* when mouse mode is on, this is the warp center: */
-  gint tme_gtk_screen_mouse_warp_x;
-  gint tme_gtk_screen_mouse_warp_y;
-
-  /* when mouse mode is on, the last tme buttons state: */
-  unsigned int tme_gtk_screen_mouse_buttons_last;
 };
 
 /* a menu item: */

--- a/host/display/gtk/gtk-mouse.c
+++ b/host/display/gtk/gtk-mouse.c
@@ -40,6 +40,7 @@ _TME_RCSID("$Id: gtk-mouse.c,v 1.3 2007/03/03 15:33:22 fredette Exp $");
 #include "gtk-display.h"
 #include <gdk/gdkkeysyms.h>
 
+#if 0
 /* this warps the pointer to the middle of the Gtkframe: */
 void
 _tme_gtk_mouse_warp_pointer(struct tme_gtk_screen *screen)
@@ -51,133 +52,56 @@ _tme_gtk_mouse_warp_pointer(struct tme_gtk_screen *screen)
 
   gdk_device_warp(gdk_seat_get_pointer(display->tme_gdk_display_seat),
 		  gdk_screen_get_default(),
-		  screen->tme_gtk_screen_mouse_warp_x,
-		  screen->tme_gtk_screen_mouse_warp_y);
+		  screen->screen.tme_screen_mouse_warp_x,
+		  screen->screen.tme_screen_mouse_warp_y);
 }
-
+#endif
 /* this is a GTK callback for a mouse event in the framebuffer event box: */
 static int
 _tme_gtk_mouse_mouse_event(GtkWidget *widget,
 			   GdkEvent *gdk_event_raw,
-			   struct tme_gtk_screen *screen)
+			   struct tme_gtk_screen *display)
 {
-  struct tme_display *display;
-  struct tme_mouse_event tme_event;
   gint x;
   gint y;
-  guint state, button;
-  unsigned int buttons;
-  int was_empty;
-  int new_callouts;
-  int rc;
-
-  /* start the tme event: */
-  tme_event.tme_mouse_event_delta_units
-    = TME_MOUSE_UNITS_UNKNOWN;
-
-  /* recover our data structure: */
-  display = screen->screen.tme_screen_display;
-
-  /* lock the mutex: */
-  tme_mutex_lock(&display->tme_display_mutex);
+  int button=0;
 
   /* if this is motion: */
   if (gdk_event_raw->type == GDK_MOTION_NOTIFY) {
 
-    /* this event must have happened in the gtkframe: */
-    assert (gdk_event_raw->motion.window
-	    == gtk_widget_get_window(screen->tme_gtk_screen_gtkframe));
-
-    /* set the event time: */
-    tme_event.tme_mouse_event_time
-      = gdk_event_raw->motion.time;
-
-    /* the buttons haven't changed: */
-    tme_event.tme_mouse_event_buttons =
-      screen->tme_gtk_screen_mouse_buttons_last;
-
     /* if the pointer position hasn't changed either, return now.
        every time we warp the pointer we will get a motion event, and
        this should ignore those events: */
     x = gdk_event_raw->motion.x_root;
     y = gdk_event_raw->motion.y_root;
-    if (x == screen->tme_gtk_screen_mouse_warp_x
-	&& y == screen->tme_gtk_screen_mouse_warp_y) {
-      
-      /* unlock the mutex: */
-      tme_mutex_unlock(&display->tme_display_mutex);
-
-      /* stop propagating this event: */
-      return (TRUE);
-    }
-
-  }
-
-  /* otherwise, if this is a double- or triple-click: */
-  else if (gdk_event_raw->type == GDK_2BUTTON_PRESS
-	   || gdk_event_raw->type == GDK_3BUTTON_PRESS) {
-
-    /* we ignore double- and triple-click events, since normal button
-       press and release events are always generated also: */
-      
-    /* unlock the mutex: */
-    tme_mutex_unlock(&display->tme_display_mutex);
 
-    /* stop propagating this event: */
-    return (TRUE);
   }
 
   /* otherwise, this must be a button press or a release: */
   else {
-    assert (gdk_event_raw->type == GDK_BUTTON_PRESS
-	    || gdk_event_raw->type == GDK_BUTTON_RELEASE);
-
-    /* this event must have happened in the gtkframe: */
-    assert (gdk_event_raw->button.window
-	    == gtk_widget_get_window(screen->tme_gtk_screen_gtkframe));
-
-    /* set the event time: */
-    tme_event.tme_mouse_event_time
-      = gdk_event_raw->button.time;
 
     /* get the pointer position: */
     x = gdk_event_raw->button.x_root;
     y = gdk_event_raw->button.y_root;
 
     /* make the buttons mask: */
-    buttons = 0;
     button = gdk_event_raw->button.button;
-    state = gdk_event_raw->button.state;
-#define _TME_GTK_MOUSE_BUTTON(i, gdk, tme)		\
-  if ((button == i)					\
-      ? (gdk_event_raw->type == GDK_BUTTON_PRESS)	\
-      : (state & gdk))					\
-      buttons |= tme
-    _TME_GTK_MOUSE_BUTTON(1, GDK_BUTTON1_MASK, TME_MOUSE_BUTTON_0);
-    _TME_GTK_MOUSE_BUTTON(2, GDK_BUTTON2_MASK, TME_MOUSE_BUTTON_1);
-    _TME_GTK_MOUSE_BUTTON(3, GDK_BUTTON3_MASK, TME_MOUSE_BUTTON_2);
-    _TME_GTK_MOUSE_BUTTON(4, GDK_BUTTON4_MASK, TME_MOUSE_BUTTON_3);
-    _TME_GTK_MOUSE_BUTTON(5, GDK_BUTTON5_MASK, TME_MOUSE_BUTTON_4);
-#undef _TME_GTK_MOUSE_BUTTON
-    tme_event.tme_mouse_event_buttons = buttons;
-    screen->tme_gtk_screen_mouse_buttons_last = buttons;
+    if(gdk_event_raw->type == GDK_BUTTON_RELEASE)
+      button = -button;
   }
 
-  /* make the deltas: */
-  tme_event.tme_mouse_event_delta_x = 
-    (((int) x)
-     - ((int) screen->tme_gtk_screen_mouse_warp_x));
-  tme_event.tme_mouse_event_delta_y = 
-    (((int) y)
-     - ((int) screen->tme_gtk_screen_mouse_warp_y));
+  /* otherwise, if this is a double- or triple-click: */
+  if (gdk_event_raw->type != GDK_2BUTTON_PRESS
+      && gdk_event_raw->type != GDK_3BUTTON_PRESS) {
 
-  screen->tme_gtk_screen_mouse_warp_x = x;
-  screen->tme_gtk_screen_mouse_warp_y = y;
-  
-  _tme_mouse_mouse_event(&tme_event, display);
+    /* we ignore double- and triple-click events, since normal button
+       press and release events are always generated also: */
+    assert (gdk_event_raw->type == GDK_BUTTON_PRESS
+	    || gdk_event_raw->type == GDK_BUTTON_RELEASE);
+
+    _tme_mouse_button_press(button, x, y, display);
   
-  /* unlock the mutex: */
-  tme_mutex_unlock(&display->tme_display_mutex);
+  }
 
   /* stop propagating this event: */
   return (TRUE);
@@ -267,8 +191,8 @@ _tme_gtk_mouse_ebox_event(GtkWidget *widget,
 
   gdk_device_get_position(gdk_seat_get_pointer(display->tme_gdk_display_seat),
 			  NULL,
-			  &screen->tme_gtk_screen_mouse_warp_x,
-			  &screen->tme_gtk_screen_mouse_warp_y);
+			  &display->display.tme_screen_mouse_warp_x,
+			  &display->display.tme_screen_mouse_warp_y);
   
   /* we are now in mouse mode: */
   screen->tme_gtk_screen_mouse_keyval
@@ -319,13 +243,9 @@ _tme_gtk_mouse_mode_off(struct tme_gtk_screen *screen,
 void
 _tme_gtk_mouse_attach(struct tme_gtk_screen *screen)
 {
-  struct tme_display *display;
   GtkWidget *hbox0;
   GtkWidget *ebox;
 
-  /* get the display: */
-  display = screen->screen.tme_screen_display;
-
   /* create the horizontal packing box for the mouse controls: */
   hbox0 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 
@@ -402,15 +322,15 @@ _tme_gtk_mouse_attach(struct tme_gtk_screen *screen)
   g_signal_connect(screen->tme_gtk_screen_gtkframe,
 		   "motion_notify_event",
 		   G_CALLBACK(_tme_gtk_mouse_mouse_event), 
-		   screen);
+		   screen->screen.tme_screen_display);
   g_signal_connect(screen->tme_gtk_screen_gtkframe,
 		   "button_press_event",
 		   G_CALLBACK(_tme_gtk_mouse_mouse_event), 
-		   screen);
+		   screen->screen.tme_screen_display);
   g_signal_connect(screen->tme_gtk_screen_gtkframe,
 		   "button_release_event",
 		   G_CALLBACK(_tme_gtk_mouse_mouse_event), 
-		   screen);
+		   screen->screen.tme_screen_display);
 
   /* mouse mode is off: */
   screen->tme_gtk_screen_mouse_keyval = GDK_KEY_VoidSymbol;

--- a/host/display/rfb/rfb-display.c
+++ b/host/display/rfb/rfb-display.c
@@ -41,44 +41,18 @@
 #include <stdlib.h>
 
 static const int bpp=4;
-static struct tme_display *_display;
-/* TODO: odd maxx doesn't work (vncviewer bug) */
-
-typedef struct tme_rfb_screen {
-  int tme_rfb_screen_mouse_buttons_last,
-    tme_rfb_screen_mouse_warp_x,
-    tme_rfb_screen_mouse_warp_y;
-} tme_rfb_screen;
-
-typedef struct tme_rfb_display {
-  /* the generic display structure */
-  struct tme_display display;
-
-  rfbScreenInfoPtr server;
-} tme_rfb_display;
-
-static void _tme_rfb_clientgone(rfbClientPtr cl)
-{
-  free(cl->clientData);
-  cl->clientData = NULL;
-}
 
-static enum rfbNewClientAction _tme_rfb_newclient(rfbClientPtr cl)
-{
-  cl->clientData = tme_new0(struct tme_rfb_screen, 1);
-  cl->clientGoneHook = _tme_rfb_clientgone;
-  return RFB_CLIENT_ACCEPT;
-}
+/* TODO: odd maxx doesn't work (vncviewer bug) */
 
 static void
-_tme_rfb_display_bell(struct tme_rfb_display *display) {
-  rfbSendBell(display->server);
+_tme_rfb_display_bell(struct tme_display *display) {
+  rfbSendBell(display->tme_screen_data);
 }
 
 static int
 _tme_rfb_display_update(struct tme_display *display) {
   long usec;
-  rfbScreenInfoPtr server = ((tme_rfb_display *)display)->server;
+  rfbScreenInfoPtr server = display->tme_screen_data;
   
   if(!rfbIsActive(server)) return 1;
 
@@ -89,15 +63,12 @@ _tme_rfb_display_update(struct tme_display *display) {
 
 /* this is called before the screen's display is updated: */
 static void
-_tme_rfb_screen_redraw(struct tme_screen *screen)
+_tme_rfb_screen_redraw(struct tme_screen *screen, int x, int y, int w, int h)
 {
-  struct tme_fb_connection *conn_fb = screen->tme_screen_fb;
-  rfbScreenInfoPtr server = ((tme_rfb_display *)screen->tme_screen_display)->server;
+  rfbScreenInfoPtr server = screen->tme_screen_display->tme_screen_data;
   
-  if((char *)conn_fb->tme_fb_connection_buffer == server->frameBuffer)
-    rfbMarkRectAsModified(server, 0, 0,
-			  conn_fb->tme_fb_connection_width,
-			  conn_fb->tme_fb_connection_height);
+  if((char *)screen->tme_screen_fb->tme_fb_connection_buffer == server->frameBuffer)
+    rfbMarkRectAsModified(server, x, y, w, h);
 }
 
 /* switch to new framebuffer contents */
@@ -107,9 +78,10 @@ static void _tme_rfb_screen_resize(struct tme_screen *screen)
   struct tme_fb_connection *conn_fb = screen->tme_screen_fb;
   int width = conn_fb->tme_fb_connection_width;
   int height = conn_fb->tme_fb_connection_height;
-  rfbScreenInfoPtr server = ((tme_rfb_display *)screen->tme_screen_display)->server;
+  rfbScreenInfoPtr server = screen->tme_screen_display->tme_screen_data;
 
   conn_fb->tme_fb_connection_buffsz = width * height * bpp;   
+  conn_fb->tme_fb_connection_scanline_pad = _tme_scanline_pad(width * bpp);
   newfb = (unsigned char*)tme_malloc(conn_fb->tme_fb_connection_buffsz);
   if(!conn_fb->tme_fb_connection_buffer ||
      (char *)conn_fb->tme_fb_connection_buffer == server->frameBuffer) {
@@ -122,25 +94,19 @@ static void _tme_rfb_screen_resize(struct tme_screen *screen)
 
 /* this makes a new screen: */
 struct tme_screen *
-_tme_rfb_screen_new(struct tme_rfb_display *display,
+_tme_rfb_screen_new(struct tme_display *display,
 		    struct tme_connection *conn)
 {
   struct tme_screen *screen;
   struct tme_fb_connection *conn_fb;
-  rfbPixelFormat* format=&display->server->serverFormat;
-
-  /* lock our mutex: */
-  tme_mutex_lock(&display->display.tme_display_mutex);
+  rfbPixelFormat* format=&((rfbScreenInfoPtr)display->tme_screen_data)->serverFormat;
 
   screen = tme_screen_new(display, struct tme_screen, conn);
 
-  screen->tme_screen_scale = 1;
-  
   conn_fb = screen->tme_screen_fb;
 
   /* update our framebuffer connection: */
   conn_fb->tme_fb_connection_skipx = 0;
-  conn_fb->tme_fb_connection_scanline_pad = 4 * bpp;
   conn_fb->tme_fb_connection_order = (format->bigEndian) ? (TME_ENDIAN_BIG) : (TME_ENDIAN_LITTLE);
   conn_fb->tme_fb_connection_bits_per_pixel = format->bitsPerPixel;
   conn_fb->tme_fb_connection_depth = format->depth;
@@ -149,144 +115,69 @@ _tme_rfb_screen_new(struct tme_rfb_display *display,
   conn_fb->tme_fb_connection_mask_b = format->blueMax << format->blueShift;
   conn_fb->tme_fb_connection_mask_r = format->redMax << format->redShift;
   
-  _tme_screen_configure(screen);
-
-  /* unlock our mutex: */
-  tme_mutex_unlock(&display->display.tme_display_mutex);
-
   /* We've handled the configure event, no need for further processing. */
   return (screen);
 }
 
-/* this is a VNC callback for a key press or release event: */
-static void
-_tme_rfb_key_event(rfbBool down, rfbKeySym key, rfbClientPtr cl)
-{
-  struct tme_keyboard_event tme_event;
-
-  /* make a tme event from this rfb event: */
-  tme_event.tme_keyboard_event_type
-    = (down
-       ? TME_KEYBOARD_EVENT_PRESS
-       : TME_KEYBOARD_EVENT_RELEASE);
-  tme_event.tme_keyboard_event_modifiers
-    = TME_KEYBOARD_MODIFIER_NONE;
-  tme_event.tme_keyboard_event_keyval
-    = key;
-  tme_event.tme_keyboard_event_time = tme_thread_get_time();
-
-  /* lock the mutex: */
-  tme_mutex_lock(&_display->tme_display_mutex);
-
-  _tme_keyboard_key_event(&tme_event, _display);
-  
-  /* unlock the mutex: */
-  tme_mutex_unlock(&_display->tme_display_mutex);
+static struct tme_display *display;
 
+static void _tme_rfb_clientgone(rfbClientPtr cl)
+{
+  cl->clientData = NULL;
 }
 
-/* this is a VNC callback for a mouse event: */
-static int
-_tme_rfb_mouse_event(int buttonMask, int x, int y, rfbClientPtr cl)
+static enum rfbNewClientAction _tme_rfb_newclient(rfbClientPtr cl)
 {
-  struct tme_mouse_event tme_event;
-  struct tme_rfb_screen *screen = (tme_rfb_screen *)cl->clientData;
-  
-  /* start the tme event: */
-  tme_event.tme_mouse_event_delta_units
-    = TME_MOUSE_UNITS_UNKNOWN;
-
-  /* lock the mutex: */
-  tme_mutex_lock(&_display->tme_display_mutex);
-
-  /* set the event time: */
-  tme_event.tme_mouse_event_time = tme_thread_get_time();
-
-  /* if the button mask and pointer position haven't changed, return now.
-     every time we warp the pointer we will get a motion event, and
-     this should ignore those events: */
-
-  if (buttonMask == screen->tme_rfb_screen_mouse_buttons_last
-      && x == screen->tme_rfb_screen_mouse_warp_x
-      && y == screen->tme_rfb_screen_mouse_warp_y) {
-    
-    /* unlock the mutex: */
-    tme_mutex_unlock(&_display->tme_display_mutex);
-    
-    /* stop propagating this event: */
-    return (TRUE);
-  }
-  
-  /* make the buttons mask: */
-  tme_event.tme_mouse_event_buttons =
-    screen->tme_rfb_screen_mouse_buttons_last = buttonMask;
-  
-  /* make the deltas: */
-  tme_event.tme_mouse_event_delta_x = 
-    (((int) x)
-     - ((int) screen->tme_rfb_screen_mouse_warp_x));
-  tme_event.tme_mouse_event_delta_y = 
-    (((int) y)
-     - ((int) screen->tme_rfb_screen_mouse_warp_y));
-
-  screen->tme_rfb_screen_mouse_warp_x = x;
-  screen->tme_rfb_screen_mouse_warp_y = y;
-  
-  _tme_mouse_mouse_event(&tme_event, _display);
-  
-  /* unlock the mutex: */
-  tme_mutex_unlock(&_display->tme_display_mutex);
-
-  rfbDefaultPtrAddEvent(buttonMask, x, y, cl);
- 
-  /* stop propagating this event: */
-  return (TRUE);
+  cl->clientData = display;
+  cl->clientGoneHook = _tme_rfb_clientgone;
+  return RFB_CLIENT_ACCEPT;
 }
 
+static struct tme_display *tme_rfb_display(rfbClientPtr cl) { return cl->clientData; }
+
 /* the new RFB display function: */
 TME_ELEMENT_SUB_NEW_DECL(tme_host_rfb,display) {
   rfbScreenInfoPtr server;
-  struct tme_rfb_display *display;
   int arg_i = 0;
 
   while(args[++arg_i] != NULL);
   
   /* start our data structure: */
-  display = tme_new0(struct tme_rfb_display, 1);
-  tme_display_init(element, display);
+  tme_display_init(element, 0);
 
+  _tme_display_get = tme_rfb_display;
+  
   /* recover our data structure: */
   display = element->tme_element_private;
 
   /* allocate initial screen structure of the given size: */
   //  rfbProcessSizeArguments(&maxx, &maxy, &bpp, &arg_i, args);
   server=rfbGetScreen(&arg_i,args,
-		      display->display.tme_screen_width,
-		      display->display.tme_screen_height,
+		      display->tme_screen_width,
+		      display->tme_screen_height,
 		      8,3,bpp);
   if(!server)
     return 1;
   server->desktopName = "The Machine Emulator";
-  server->frameBuffer = (char*)tme_malloc(display->display.tme_screen_width *
-					  display->display.tme_screen_height *
+  server->frameBuffer = (char*)tme_malloc(display->tme_screen_width *
+					  display->tme_screen_height *
 					  bpp);
   server->alwaysShared = TRUE;
-  server->ptrAddEvent = _tme_rfb_mouse_event;
-  server->kbdAddEvent = _tme_rfb_key_event;
+  server->ptrAddEvent = _tme_mouse_buttons_event;
+  server->kbdAddEvent = _tme_keyboard_key_press;
   server->newClientHook = _tme_rfb_newclient;
   //  server->httpDir = "../webclients";
   //  server->httpEnableProxyConnect = TRUE;
   rfbInitServer(server);
   
-  display->server = server;
+  display->tme_screen_data = server;
 
   /* set the display-specific functions: */
-  display->display.tme_display_bell = _tme_rfb_display_bell;
-  display->display.tme_display_update = _tme_rfb_display_update;
-  display->display.tme_screen_add = _tme_rfb_screen_new;
-  display->display.tme_screen_resize = _tme_rfb_screen_resize;
-  display->display.tme_screen_redraw = _tme_rfb_screen_redraw;
+  display->tme_display_bell = _tme_rfb_display_bell;
+  display->tme_display_update = _tme_rfb_display_update;
+  display->tme_screen_add = _tme_rfb_screen_new;
+  display->tme_screen_resize = _tme_rfb_screen_resize;
+  display->tme_screen_redraw = _tme_rfb_screen_redraw;
 
-  _display = display;
   return (TME_OK);
 }

--- /dev/null
+++ b/host/display/sdl/sdl-display.c
@@ -0,0 +1,385 @@
+/* host/sdl/sdl-display.c - SDL2 support: */
+
+/*
+ * Copyright (c) 2022 Ruben Agin
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Matt Fredette.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <tme/common.h>
+
+/* includes: */
+#include "display.h"
+#include <SDL.h>
+#include <signal.h>
+
+struct { char mask; int bits_stored; } utf8Mapping[]= {
+        {0b00111111, 6},
+        {0b01111111, 7},
+        {0b00011111, 5},
+        {0b00001111, 4},
+        {0b00000111, 3},
+        {0,0}
+};
+
+/* TODO: odd maxx doesn't work (vncviewer bug) */
+
+static int enableResizable = 1, viewOnly, listenLoop;
+struct tme_sdl_screen {
+  /* the generic screen structure */
+  struct tme_screen screen;
+  int sdlFlags;
+  SDL_Surface* sdl;
+  SDL_Texture *sdlTexture;
+  SDL_Renderer *sdlRenderer;
+  SDL_Window *sdlWindow;
+};
+
+/* client's pointer position */
+int x,y;
+static int rightAltKeyDown, leftAltKeyDown;
+/* switch to new framebuffer contents */
+static void _tme_sdl_screen_resize(struct tme_sdl_screen *screen)
+{
+  unsigned char *oldfb, *newfb;
+  struct tme_fb_connection *conn_fb = screen->screen.tme_screen_fb;
+  int width = conn_fb->tme_fb_connection_width;
+  int height = conn_fb->tme_fb_connection_height;
+  int depth = SDL_BITSPERPIXEL(SDL_PIXELFORMAT_RGBA32);
+
+  if (enableResizable)
+    screen->sdlFlags |= SDL_WINDOW_RESIZABLE;
+  
+  /* (re)create the surface used as the client's framebuffer */
+  SDL_FreeSurface(screen->sdl);
+  screen->sdl=SDL_CreateRGBSurface(0,
+				   width,
+				   height,
+				   depth,
+				   0,0,0,0);
+  if(!screen->sdl)
+        tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+	    (&display->tme_display_element->tme_element_log_handle,
+	     _("resize: error creating surface: %s\n", SDL_GetError())));
+
+  /* update our framebuffer connection: */
+  conn_fb->tme_fb_connection_width = screen->sdl->pitch / (depth / 8);
+  conn_fb->tme_fb_connection_buffer = screen->sdl->pixels;
+  conn_fb->tme_fb_connection_buffsz = screen->sdl->pitch * height;   
+  conn_fb->tme_fb_connection_skipx = 0;
+  conn_fb->tme_fb_connection_scanline_pad = _tme_scanline_pad(screen->sdl->pitch);
+  conn_fb->tme_fb_connection_order = TME_ENDIAN_LITTLE;
+  conn_fb->tme_fb_connection_bits_per_pixel = depth;
+  conn_fb->tme_fb_connection_depth = 24;
+  conn_fb->tme_fb_connection_class = TME_FB_XLAT_CLASS_COLOR;
+  conn_fb->tme_fb_connection_mask_g = screen->sdl->format->Gmask >> screen->sdl->format->Gshift;
+  conn_fb->tme_fb_connection_mask_b = screen->sdl->format->Bmask >> screen->sdl->format->Bshift;
+  conn_fb->tme_fb_connection_mask_r = screen->sdl->format->Rmask >> screen->sdl->format->Rshift;
+  /* create or resize the window */
+  if(!screen->sdlWindow) {
+    screen->sdlWindow = SDL_CreateWindow(display->desktopName,
+					 SDL_WINDOWPOS_UNDEFINED,
+					 SDL_WINDOWPOS_UNDEFINED,
+					 width,
+					 height,
+					 screen->sdlFlags);
+    if(!screen->sdlWindow)
+          tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+	    (&display->tme_display_element->tme_element_log_handle,
+	     _("resize: error creating window: %s\n", SDL_GetError())));
+  } else {
+    SDL_SetWindowSize(screen->sdlWindow, width, height);
+  }
+  /* create the renderer if it does not already exist */
+  if(!screen->sdlRenderer) {
+    screen->sdlRenderer = SDL_CreateRenderer(screen->sdlWindow, -1, 0);
+    if(!screen->sdlRenderer)
+          tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+	    (&display->tme_display_element->tme_element_log_handle,
+	     _("resize: error creating renderer: %s\n", SDL_GetError())));
+    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");  /* make the scaled rendering look smoother. */
+  }
+  SDL_RenderSetLogicalSize(screen->sdlRenderer, width, height);  /* this is a departure from the SDL1.2-based version, but more in the sense of a VNC viewer in keeeping aspect ratio */
+  /* (re)create the texture that sits in between the surface->pixels and the renderer */
+  if(screen->sdlTexture)
+    SDL_DestroyTexture(screen->sdlTexture);
+  screen->sdlTexture = SDL_CreateTexture(screen->sdlRenderer,
+					 SDL_PIXELFORMAT_ARGB8888,
+					 SDL_TEXTUREACCESS_STREAMING,
+					 width, height);
+  if(!screen->sdlTexture)
+        tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+	    (&display->tme_display_element->tme_element_log_handle,
+	     _("resize: error creating texture: %s\n", SDL_GetError())));
+  return TRUE;
+}
+#if 0
+static tme_keyboard_keyval_t SDL_key2rfbKeySym(SDL_KeyboardEvent* e) {
+        tme_keyboard_keyval_t k = 0;
+        SDL_Keycode sym = e->keysym.sym;
+        switch (sym) {
+        case SDLK_BACKSPACE: k = XK_BackSpace; break;
+        case SDLK_TAB: k = XK_Tab; break;
+        case SDLK_CLEAR: k = XK_Clear; break;
+        case SDLK_RETURN: k = XK_Return; break;
+        case SDLK_PAUSE: k = XK_Pause; break;
+        case SDLK_ESCAPE: k = XK_Escape; break;
+        case SDLK_DELETE: k = XK_Delete; break;
+        case SDLK_KP_0: k = XK_KP_0; break;
+        case SDLK_KP_1: k = XK_KP_1; break;
+        case SDLK_KP_2: k = XK_KP_2; break;
+        case SDLK_KP_3: k = XK_KP_3; break;
+        case SDLK_KP_4: k = XK_KP_4; break;
+        case SDLK_KP_5: k = XK_KP_5; break;
+        case SDLK_KP_6: k = XK_KP_6; break;
+        case SDLK_KP_7: k = XK_KP_7; break;
+        case SDLK_KP_8: k = XK_KP_8; break;
+        case SDLK_KP_9: k = XK_KP_9; break;
+        case SDLK_KP_PERIOD: k = XK_KP_Decimal; break;
+        case SDLK_KP_DIVIDE: k = XK_KP_Divide; break;
+        case SDLK_KP_MULTIPLY: k = XK_KP_Multiply; break;
+        case SDLK_KP_MINUS: k = XK_KP_Subtract; break;
+        case SDLK_KP_PLUS: k = XK_KP_Add; break;
+        case SDLK_KP_ENTER: k = XK_KP_Enter; break;
+        case SDLK_KP_EQUALS: k = XK_KP_Equal; break;
+        case SDLK_UP: k = XK_Up; break;
+        case SDLK_DOWN: k = XK_Down; break;
+        case SDLK_RIGHT: k = XK_Right; break;
+        case SDLK_LEFT: k = XK_Left; break;
+        case SDLK_INSERT: k = XK_Insert; break;
+        case SDLK_HOME: k = XK_Home; break;
+        case SDLK_END: k = XK_End; break;
+        case SDLK_PAGEUP: k = XK_Page_Up; break;
+        case SDLK_PAGEDOWN: k = XK_Page_Down; break;
+        case SDLK_F1: k = XK_F1; break;
+        case SDLK_F2: k = XK_F2; break;
+        case SDLK_F3: k = XK_F3; break;
+        case SDLK_F4: k = XK_F4; break;
+        case SDLK_F5: k = XK_F5; break;
+        case SDLK_F6: k = XK_F6; break;
+        case SDLK_F7: k = XK_F7; break;
+        case SDLK_F8: k = XK_F8; break;
+        case SDLK_F9: k = XK_F9; break;
+        case SDLK_F10: k = XK_F10; break;
+        case SDLK_F11: k = XK_F11; break;
+        case SDLK_F12: k = XK_F12; break;
+        case SDLK_F13: k = XK_F13; break;
+        case SDLK_F14: k = XK_F14; break;
+        case SDLK_F15: k = XK_F15; break;
+        case SDLK_NUMLOCKCLEAR: k = XK_Num_Lock; break;
+        case SDLK_CAPSLOCK: k = XK_Caps_Lock; break;
+        case SDLK_SCROLLLOCK: k = XK_Scroll_Lock; break;
+        case SDLK_RSHIFT: k = XK_Shift_R; break;
+        case SDLK_LSHIFT: k = XK_Shift_L; break;
+        case SDLK_RCTRL: k = XK_Control_R; break;
+        case SDLK_LCTRL: k = XK_Control_L; break;
+        case SDLK_RALT: k = XK_Alt_R; break;
+        case SDLK_LALT: k = XK_Alt_L; break;
+        case SDLK_LGUI: k = XK_Super_L; break;
+        case SDLK_RGUI: k = XK_Super_R; break;
+#if 0
+        case SDLK_COMPOSE: k = XK_Compose; break;
+#endif
+        case SDLK_MODE: k = XK_Mode_switch; break;
+        case SDLK_HELP: k = XK_Help; break;
+        case SDLK_PRINTSCREEN: k = XK_Print; break;
+        case SDLK_SYSREQ: k = XK_Sys_Req; break;
+        default: break;
+        }
+        /* SDL_TEXTINPUT does not generate characters if ctrl is down, so handle those here */
+        if (k == 0 && sym > 0x0 && sym < 0x100 && e->keysym.mod & KMOD_CTRL)
+               k = sym;
+        return k;
+}
+#endif
+/* UTF-8 decoding is from https://rosettacode.org/wiki/UTF-8_encode_and_decode which is under GFDL 1.2 */
+static tme_keyboard_keyval_t utf8char2rfbKeySym(const char chr[4]) {
+        int bytes = strlen(chr);
+        int shift = utf8Mapping[0].bits_stored * (bytes - 1);
+        tme_keyboard_keyval_t codep = (*chr++ & utf8Mapping[bytes].mask) << shift;
+        int i;
+        for(i = 1; i < bytes; ++i, ++chr) {
+                shift -= utf8Mapping[0].bits_stored;
+                codep |= ((char)*chr & utf8Mapping[0].mask) << shift;
+        }
+        return codep;
+}
+static void
+_tme_sdl_screen_redraw(struct tme_sdl_screen *screen, int x, int y, int w, int h)
+{
+  SDL_Surface *sdl = screen->sdl;
+  /* update texture from surface->pixels */
+  SDL_Rect r = {x,y,w,h};
+  if(SDL_UpdateTexture(screen->sdlTexture, &r, sdl->pixels + y*sdl->pitch + x*4, sdl->pitch) < 0)
+        tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+	    (&display->tme_display_element->tme_element_log_handle,
+	     _("update: failed to update texture: %s\n", SDL_GetError())));
+  /* copy texture to renderer and show */
+  if(SDL_RenderClear(screen->sdlRenderer) < 0)
+        tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+	    (&display->tme_display_element->tme_element_log_handle,
+	     _("update: failed to clear renderer: %s\n", SDL_GetError())));
+  if(SDL_RenderCopy(screen->sdlRenderer, screen->sdlTexture, NULL, NULL) < 0)
+        tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+	    (&display->tme_display_element->tme_element_log_handle,
+	     _("update: failed to copy texture to renderer: %s\n", SDL_GetError())));
+  SDL_RenderPresent(screen->sdlRenderer);
+}
+static int
+_tme_sdl_display_update(struct tme_display *display) {
+  SDL_Event e;
+
+  if(SDL_PollEvent(&e)) {
+
+    switch(e->type) {
+    case SDL_WINDOWEVENT:
+      switch (e->window.event) {
+      case SDL_WINDOWEVENT_EXPOSED:
+	SendFramebufferUpdateRequest(cl, 0, 0,
+				     cl->width, cl->height, FALSE);
+	break;
+      case SDL_WINDOWEVENT_FOCUS_LOST:
+	if (rightAltKeyDown) {
+	  _tme_keyboard_key_press(FALSE, SDLK_RALT, display);
+	  rightAltKeyDown = FALSE;
+	  tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+		  (&display->tme_display_element->tme_element_log_handle,
+		   _("released right Alt key\n")));
+	}
+	if (leftAltKeyDown) {
+	  _tme_keyboard_key_press(FALSE, SDLK_LALT, display);
+	  leftAltKeyDown = FALSE;
+	  tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+		  (&display->tme_display_element->tme_element_log_handle,
+		   _("released left Alt key\n")));
+	}
+	break;
+      }
+      break;
+    case SDL_MOUSEWHEEL:
+      {
+	int steps;
+	if (viewOnly)
+	  break;
+	if(e->wheel.y > 0)
+	  for(steps = 0; steps < e->wheel.y; ++steps) {
+	    _tme_mouse_button_press(4, x, y, display);
+	    _tme_mouse_button_press(-4, x, y, display);
+	  }
+	if(e->wheel.y < 0)
+	  for(steps = 0; steps > e->wheel.y; --steps) {
+	    _tme_mouse_button_press(5, x, y, display);
+	    _tme_mouse_button_press(-5, x, y, display);
+	  }
+	if(e->wheel.x > 0)
+	  for(steps = 0; steps < e->wheel.x; ++steps) {
+	    _tme_mouse_button_press(7, x, y, display);
+	    _tme_mouse_button_press(-7, x, y, display);
+	  }
+	if(e->wheel.x < 0)
+	  for(steps = 0; steps > e->wheel.x; --steps) {
+	    _tme_mouse_button_press(6, x, y, display);
+	    _tme_mouse_button_press(-6, x, y, display);
+	  }
+	break;
+      }
+    case SDL_MOUSEBUTTONUP:
+    case SDL_MOUSEBUTTONDOWN:
+    case SDL_MOUSEMOTION:
+      {
+	int button, i;
+	if (viewOnly)
+	  break;
+	if (e->type == SDL_MOUSEMOTION) {
+	  x = e->motion.x;
+	  y = e->motion.y;
+	  button = 0; // e->motion.state;
+	}
+	else {
+	  x = e->button.x;
+	  y = e->button.y;
+	  button = e->button.button;
+	  if (e->type == SDL_MOUSEBUTTONUP)
+	    button = -button;
+	}
+	_tme_mouse_button_press(button, x, y, display);
+	break;
+      }
+    case SDL_KEYUP:
+    case SDL_KEYDOWN:
+      if (viewOnly)
+	break;
+      _tme_keyboard_key_press(e->type == SDL_KEYDOWN ? TRUE : FALSE,
+			      e->keysym.sym, display);
+      if (e->key.keysym.sym == SDLK_RALT)
+	rightAltKeyDown = e->type == SDL_KEYDOWN;
+      if (e->key.keysym.sym == SDLK_LALT)
+	leftAltKeyDown = e->type == SDL_KEYDOWN;
+      break;
+    case SDL_TEXTINPUT:
+      if (viewOnly)
+	break;
+      tme_keyboard_keyval_t sym = utf8char2rfbKeySym(e->text.text);
+      _tme_keyboard_key_press(TRUE, sym, display);
+      _tme_keyboard_key_press(FALSE, sym, display);
+      break;
+    default:
+      tme_log(&display->tme_display_element->tme_element_log_handle, 0, TME_OK,
+	      (&display->tme_display_element->tme_element_log_handle,
+	       _("ignore SDL event: 0x%x\n", e->type)));
+    }
+    return TRUE;
+  }
+}
+  
+/* the new SDL display function: */
+TME_ELEMENT_SUB_NEW_DECL(tme_host_sdl,display) {
+  struct tme_display *display;
+  int arg_i = 0;
+
+  while(args[++arg_i] != NULL);
+  
+  /* start our data structure: */
+  display = tme_new0(struct tme_display, 1);
+  tme_display_init(element, display);
+
+  /* recover our data structure: */
+  display = element->tme_element_private;
+
+  SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE);
+  atexit(SDL_Quit);
+  signal(SIGINT, exit);
+
+  /* set the display-specific functions: */
+  //  display->tme_display_bell = _tme_sdl_display_bell;
+  display->tme_display_update = _tme_sdl_display_update;
+  display->tme_screen_resize = _tme_sdl_screen_resize;
+  display->tme_screen_redraw = _tme_sdl_screen_redraw;
+
+  return (TME_OK);
+}