Commit: f9fc4878bc05dd4e9375e09829b4e7fa2c8a02f5 - tme (git)

Commit MetaInfo

• Révision: f9fc4878bc05dd4e9375e09829b4e7fa2c8a02f5 (tree)
• l'heure: 2023-03-19 14:33:27
• Auteur: phabrics <phabrics@phab...>
• Commiter: phabrics

Message de Log

Finalized structure of display for GTK4 migration.

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/gtk-display.h
• modified: host/display/gtk/gtk-keyboard.c
• modified: host/display/gtk/gtk-mouse.c
• modified: host/display/rfb/rfb-display.c

Modification

--- a/host/display/display-keyboard.c
+++ b/host/display/display-keyboard.c
@@ -227,10 +227,9 @@ _tme_keyboard_keyval_name(tme_keyboard_keyval_t keyval)
 
 /* this is a generic callback for a key press or release event: */
 int
-_tme_keyboard_key_event(int down, tme_keyboard_keyval_t key, void *disp)
+_tme_keyboard_key_event(int down, tme_keyboard_keyval_t key, struct tme_display *display)
 {
   struct tme_keyboard_event tme_event;
-  struct tme_display *display = (_tme_display_get) ? (_tme_display_get(disp)) : (disp);
   int was_empty;
   int new_callouts;
   int rc;

--- a/host/display/display-mouse.c
+++ b/host/display/display-mouse.c
@@ -53,31 +53,23 @@ _tme_mouse_debug(const struct tme_mouse_event *event)
 #endif
 
 /* this is a generic callback for a mouse event: */
-int
-_tme_mouse_button_press(int button, int x, int y, struct tme_display *display)
+void
+_tme_mouse_event(int button, int x, int y, struct tme_display *display)
 {
-  int state;
-    
+  struct tme_mouse_event tme_event;
+  int was_empty;
+  int new_callouts, rc;
+  
   /* make the buttons mask: */
-  state = display->tme_screen_mouse_buttons_last;
+  int buttons = display->tme_screen_mouse_buttons_last;
 
   if(button>0)
-    state |= TME_BIT(button-1);
+    buttons |= TME_BIT(button-1);
   else if(button) {
     button = -button;
-    state &= ~TME_BIT(button-1);
+    buttons &= ~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, 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;
@@ -100,7 +92,7 @@ int _tme_mouse_buttons_event(int buttons, int x, int y, void *disp)
     tme_mutex_unlock(&display->tme_display_mutex);
     
     /* stop propagating this event: */
-    return (TRUE);
+    return;
   }
   
   tme_event.tme_mouse_event_buttons =
@@ -145,9 +137,6 @@ int _tme_mouse_buttons_event(int buttons, int x, int y, void *disp)
 
   /* unlock the mutex: */
   tme_mutex_unlock(&display->tme_display_mutex);
-
-  /* don't process this event any further: */
-  return (TRUE);
 }
 
 /* this is called when the mouse controls change: */

--- a/host/display/display.c
+++ b/host/display/display.c
@@ -36,8 +36,6 @@
 /* includes: */
 #include "display.h"
 
-struct tme_display *(*_tme_display_get) _TME_P((void *));
-
 static int
 _tme_screen_update(struct tme_screen *screen) {
   struct tme_fb_connection *conn_fb;
@@ -689,9 +687,6 @@ int tme_display_init(struct tme_element *element,
   /* 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
@@ -186,7 +186,6 @@ _tme_scanline_pad(int bpl)
   return (8);
 }
 
-extern 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 *));
@@ -197,12 +196,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_event _TME_P((int down, tme_keyboard_keyval_t key, void *disp));
+int _tme_keyboard_key_event _TME_P((int down, tme_keyboard_keyval_t key, struct tme_display *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));
+void _tme_mouse_event _TME_P((int button, int x, int y, struct tme_display *disp));
 
 #endif /* _HOST_DISPLAY_H */
 

--- a/host/display/gtk/gtk-display.h
+++ b/host/display/gtk/gtk-display.h
@@ -98,8 +98,8 @@ typedef struct tme_gtk_screen {
   guint tme_gtk_screen_mouse_statusbar_cid;
 
   cairo_format_t tme_gtk_screen_format;
-  GtkEventControllerKey *key;
-  GtkEventControllerMotion *motion;
+  GtkEventController *key, *mouse, *motion, *event;
+  GtkGesture *press;
 
   /* when mouse mode is on, this is the previous events mask
      for the framebuffer event box: */

--- a/host/display/gtk/gtk-keyboard.c
+++ b/host/display/gtk/gtk-keyboard.c
@@ -50,9 +50,25 @@ _tme_gtk_keyboard_key_down(
   guint keyval,
   guint keycode,
   GdkModifierType* state,
-  struct tme_display *display)
+  struct tme_gtk_screen *screen)
 {
-  return _tme_keyboard_key_event(TRUE, keyval, display);
+  if(screen->tme_gtk_screen_mouse_keyval
+     != keyval)
+    return _tme_keyboard_key_event(TRUE, keyval, screen->screen.tme_screen_display);
+
+  /* pop our message off of the statusbar: */
+  gtk_statusbar_pop(GTK_STATUSBAR(screen->tme_gtk_screen_mouse_statusbar),
+		    screen->tme_gtk_screen_mouse_statusbar_cid);
+    
+  /* restore the text on the mouse label: */
+  gtk_frame_set_label(GTK_FRAME(screen->tme_gtk_screen_mouse_label),
+		      _("Mouse is off"));
+    
+  /* the mouse is now off: */
+  screen->tme_gtk_screen_mouse_keyval = GDK_KEY_VoidSymbol;
+
+  return (TRUE);
+  
 }
 
 static gboolean
@@ -61,46 +77,100 @@ _tme_gtk_keyboard_key_up(
   guint keyval,
   guint keycode,
   GdkModifierType* state,
-  struct tme_display *display)
+  struct tme_gtk_screen *screen)
+{
+  return _tme_keyboard_key_event(FALSE, keyval, screen->screen.tme_screen_display);
+}
+
+/* this sets the mouse mode, e.g., on/off.  it is called with the mutex locked: */
+static gboolean
+_tme_gtk_mouse_key_down(
+  GtkEventControllerKey* self,
+  guint keyval,
+  guint keycode,
+  GdkModifierType* state,
+  struct tme_gtk_screen *screen)
 {
-  return _tme_keyboard_key_event(FALSE, keyval, display);
+  struct tme_gtk_display *display;
+  int rc;
+  char *status;
+
+  /* recover our data structure: */
+  display = screen->screen.tme_screen_display;
+
+  if(screen->tme_gtk_screen_mouse_keyval
+     != GDK_KEY_VoidSymbol) return (FALSE);
+
+  /* lock the mutex: */
+  tme_mutex_lock(&display->display.tme_display_mutex);
+
+  /* this keyval must not be GDK_KEY_VoidSymbol: */
+  assert (keyval
+	  != GDK_KEY_VoidSymbol);
+  
+  /* set the text on the mouse label: */
+  gtk_frame_set_label(GTK_FRAME(screen->tme_gtk_screen_mouse_label),
+		      _("Mouse is on"));
+  
+  /* push the mouse status onto the statusbar: */
+  status = NULL;
+  tme_output_append(&status,
+		    _("Press the %s key to turn the mouse off"),
+		    gdk_keyval_name(keyval));
+  gtk_statusbar_push(GTK_STATUSBAR(screen->tme_gtk_screen_mouse_statusbar),
+		     screen->tme_gtk_screen_mouse_statusbar_cid,
+		     status);
+  tme_free(status);
+
+  gdk_device_get_position(gdk_seat_get_pointer(display->tme_gdk_display_seat),
+			  NULL,
+			  &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
+    = keyval;
+
+  /* unlock the mutex: */
+  tme_mutex_unlock(&display->display.tme_display_mutex);
+
+  return (TRUE);
 }
 
 /* this attaches the GTK keyboard to a new screen: */
 void
 _tme_gtk_keyboard_attach(struct tme_gtk_screen *screen)
 {
-  GtkEventControllerKey *key;
-  GtkEventControllerMotion *motion;
+  GtkEventController *key, *mouse;
 
 #if GTK_MAJOR_VERSION == 4
-  motion=gtk_event_controller_motion_new();
   key=gtk_event_controller_key_new();
-  gtk_widget_add_controller(screen->tme_gtk_screen_draw, GTK_EVENT_CONTROLLER(key));
-  gtk_widget_add_controller(screen->tme_gtk_screen_draw, GTK_EVENT_CONTROLLER(motion));
+  gtk_widget_add_controller(screen->tme_gtk_screen_draw, key);
+  gtk_widget_set_focussable(screen->tme_gtk_screen_draw, TRUE);
+  mouse=gtk_event_controller_key_new();
+  gtk_widget_add_controller(screen->tme_gtk_screen_mouse_label, mouse);
+  gtk_widget_set_focussable(screen->tme_gtk_screen_mouse_label, TRUE);
 #elif GTK_MAJOR_VERSION == 3
-  motion=screen->motion=gtk_event_controller_motion_new(screen->tme_gtk_screen_draw);
   key=screen->key=gtk_event_controller_key_new(screen->tme_gtk_screen_draw);
+  gtk_widget_set_can_focus(screen->tme_gtk_screen_draw, TRUE);
+  mouse=screen->mouse=gtk_event_controller_key_new(screen->tme_gtk_screen_mouse_label);
+  gtk_widget_set_can_focus(screen->tme_gtk_screen_mouse_label, TRUE);
 #endif
   
-  /* on entering window, grab keyboard focus: */
-  g_signal_connect_swapped(motion,
-			   "enter",
-			   G_CALLBACK(gtk_widget_grab_focus),
-			   screen->tme_gtk_screen_draw);
-
   g_signal_connect_after(key,
 			 "key-pressed",
 			 G_CALLBACK(_tme_gtk_keyboard_key_down), 
-			 screen->screen.tme_screen_display);
+			 screen);
+
   g_signal_connect_after(key,
 			 "key-released",
 			 G_CALLBACK(_tme_gtk_keyboard_key_up), 
-			 screen->screen.tme_screen_display);
-  
-  /* the event box can focus, and have it grab the focus now: */
-  gtk_widget_set_can_focus(screen->tme_gtk_screen_draw, TRUE);
-  gtk_widget_grab_focus(screen->tme_gtk_screen_draw);
+			 screen); 
+
+  g_signal_connect_after(mouse,
+			 "key-pressed",
+			 G_CALLBACK(_tme_gtk_mouse_key_down), 
+			 screen);
 
 }
 

--- a/host/display/gtk/gtk-mouse.c
+++ b/host/display/gtk/gtk-mouse.c
@@ -56,231 +56,88 @@ _tme_gtk_mouse_warp_pointer(struct tme_gtk_screen *screen)
 		  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 *display)
-{
-  gint x;
-  gint y;
-  int button=0;
-
-#if GTK_MAJOR_VERSION == 4
-  gdk_event_get_position(gdk_event_raw, &x, &y);
-  button = gdk_button_event_get_button(gdk_event_raw);
-
-#elif GTK_MAJOR_VERSION == 3
-  /* if this is motion: */
-  if (gdk_event_raw->type == GDK_MOTION_NOTIFY) {
-
-    /* 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;
-    y = gdk_event_raw->motion.y;
-
-  }
-
-  /* otherwise, this must be a button press or a release: */
-  else {
 
-    /* get the pointer position: */
-    x = gdk_event_raw->button.x;
-    y = gdk_event_raw->button.y;
-
-    /* make the buttons mask: */
-    button = gdk_event_raw->button.button;
-    if(gdk_event_raw->type == GDK_BUTTON_RELEASE)
-      button = -button;
-  }
-
-  /* otherwise, if this is a double- or triple-click: */
-  if (gdk_event_raw->type != GDK_2BUTTON_PRESS
-      && gdk_event_raw->type != GDK_3BUTTON_PRESS)
-#endif
-  {    
-    /* 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);
-  
-  }
+/* this is a GTK callback for a mouse event in the framebuffer event box: */
+static void
+_tme_gtk_mouse_motion_event(GtkEventControllerMotion* self,
+			    gdouble x,
+			    gdouble y,
+			    struct tme_gtk_screen *screen)
 
-  /* stop propagating this event: */
-  return (TRUE);
+{
+  if(screen->tme_gtk_screen_mouse_keyval
+     != GDK_KEY_VoidSymbol)
+    _tme_mouse_event(0, x, y, screen->screen.tme_screen_display);
 }
 
-/* this is a GTK callback for an event in the event box containing the
-   mouse label: */
-static int
-_tme_gtk_mouse_ebox_event(GtkWidget *widget,
-			  GdkEvent *gdk_event_raw,
-			  struct tme_gtk_screen *screen)
+/* this is a GTK callback for a mouse event in the framebuffer event box: */
+static void
+_tme_gtk_mouse_button_down(GtkGesture* self,
+			   int n_press,
+			   gdouble x,
+			   gdouble y,
+			   struct tme_gtk_screen *screen)
 {
-  struct tme_gtk_display *display;
-  int rc;
-  char *status;
-  GdkWindow *window;
-
-  /* if this is an enter notify event, grab the focus and continue
-     propagating the event: */
-  if (gdk_event_get_event_type(gdk_event_raw) == GDK_ENTER_NOTIFY) {
-    gtk_widget_grab_focus(widget);
-    return (FALSE);
-  }
-
-  /* if this is not a key press event, continue propagating it now: */
-  if (gdk_event_get_event_type(gdk_event_raw) != GDK_KEY_PRESS) {
-    return (FALSE);
-  }
-
-  /* recover our data structure: */
-  display = screen->screen.tme_screen_display;
-
-  /* lock the mutex: */
-  tme_mutex_lock(&display->display.tme_display_mutex);
-
-  /* the mouse must not be on already: */
-  assert (screen->tme_gtk_screen_mouse_keyval
-	  == GDK_KEY_VoidSymbol);
-
-  /* this keyval must not be GDK_KEY_VoidSymbol: */
-  assert (gdk_event_raw->key.keyval
-	  != GDK_KEY_VoidSymbol);
-  
-  /* set the text on the mouse label: */
-  gtk_label_set_text(GTK_LABEL(screen->tme_gtk_screen_mouse_label),
-		     _("Mouse is on"));
-  
-  /* push the mouse status onto the statusbar: */
-  status = NULL;
-  tme_output_append(&status,
-		    _("Press the %s key to turn the mouse off"),
-		    gdk_keyval_name(gdk_event_raw->key.keyval));
-  gtk_statusbar_push(GTK_STATUSBAR(screen->tme_gtk_screen_mouse_statusbar),
-		     screen->tme_gtk_screen_mouse_statusbar_cid,
-		     status);
-  tme_free(status);
-  
-  window = gtk_widget_get_window(screen->tme_gtk_screen_draw);
-
-  /* if the original events mask on the framebuffer event box have
-     never been saved, save them now, and add the mouse events: */
-  /*  if (screen->tme_gtk_screen_mouse_events_old == 0) {
-    screen->tme_gtk_screen_mouse_events_old
-      = gtk_widget_get_events(screen->tme_gtk_screen_draw);
-    gtk_widget_add_events(screen->tme_gtk_screen_draw,
-			  GDK_POINTER_MOTION_MASK
-			  | GDK_BUTTON_PRESS_MASK
-			  | GDK_BUTTON_RELEASE_MASK);
-  }
-  */
-  /* grab the pointer: */
-  gtk_grab_add(screen->tme_gtk_screen_draw);
-    /*gtk_device_grab_add(screen->tme_gtk_screen_draw,
-		      gdk_seat_get_pointer(display->tme_gdk_display_seat),
-		      FALSE);*/
-
-  rc
-    = gdk_seat_grab(display->tme_gdk_display_seat,
-		    window,
-		    GDK_SEAT_CAPABILITY_ALL_POINTING,
-		    TRUE,
-		    display->tme_gdk_display_cursor,
-		    gdk_event_raw,
-		    NULL,
-		    NULL); 
-  assert (rc == 0);
-
-  gdk_device_get_position(gdk_seat_get_pointer(display->tme_gdk_display_seat),
-			  NULL,
-			  &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
-    = gdk_event_raw->key.keyval;
-
-  /* unlock the mutex: */
-  tme_mutex_unlock(&display->display.tme_display_mutex);
-
-  /* stop propagating this event: */
-  return (TRUE);
+  if(screen->tme_gtk_screen_mouse_keyval
+     != GDK_KEY_VoidSymbol)
+    _tme_mouse_event(gtk_gesture_single_get_current_button(self),
+		     x, y, screen->screen.tme_screen_display);
 }
 
-/* this turns mouse mode off.  it is called with the mutex locked: */
-void
-_tme_gtk_mouse_mode_off(struct tme_gtk_screen *screen,
-			guint32 time)
+/* this is a GTK callback for a mouse event in the framebuffer event box: */
+static void
+_tme_gtk_mouse_button_up(GtkGesture* self,
+			 int n_press,
+			 gdouble x,
+			 gdouble y,
+			 struct tme_gtk_screen *screen)
 {
-  struct tme_gtk_display *display;
-
-  /* get the display: */
-  display = screen->screen.tme_screen_display;
-
-  /* the mouse must be on: */
-  assert (screen->tme_gtk_screen_mouse_keyval
-	  != GDK_KEY_VoidSymbol);
-
-  /* ungrab the pointer: */
-  gdk_seat_ungrab(display->tme_gdk_display_seat);
-  gtk_grab_remove(screen->tme_gtk_screen_draw);
-  //gtk_device_grab_remove(screen->tme_gtk_screen_draw, gdk_seat_get_pointer(display->tme_gdk_display_seat));
-
-  /* restore the old events mask on the event box: */
-  //  gtk_widget_set_events(screen->tme_gtk_screen_draw, screen->tme_gtk_screen_mouse_events_old);
-
-  /* pop our message off of the statusbar: */
-  gtk_statusbar_pop(GTK_STATUSBAR(screen->tme_gtk_screen_mouse_statusbar),
-		    screen->tme_gtk_screen_mouse_statusbar_cid);
-
-  /* restore the text on the mouse label: */
-  gtk_label_set_text(GTK_LABEL(screen->tme_gtk_screen_mouse_label),
-		     _("Mouse is off"));
-
-  /* the mouse is now off: */
-  screen->tme_gtk_screen_mouse_keyval = GDK_KEY_VoidSymbol;
+  if(screen->tme_gtk_screen_mouse_keyval
+     != GDK_KEY_VoidSymbol)
+    _tme_mouse_event(-gtk_gesture_single_get_current_button(self),
+		     x, y, screen->screen.tme_screen_display);
 }
 
 /* this attaches the GTK mouse to a new screen: */
 void
 _tme_gtk_mouse_attach(struct tme_gtk_screen *screen)
 {
-  GtkWidget *ebox;
+  GtkEventController *motion, *event;
+  GtkGesture *press;
 
   /* create the event box for the mouse on label: */
-  ebox = gtk_event_box_new();
+  /* create the mouse on label: */
+  screen->tme_gtk_screen_mouse_label
+    = gtk_frame_new(_("Mouse is off"));
   
   /* pack the event box into the horizontal packing box: */
-  gtk_header_bar_pack_start(GTK_HEADER_BAR(screen->tme_gtk_screen_header), ebox);
+  gtk_header_bar_pack_start(GTK_HEADER_BAR(screen->tme_gtk_screen_header),
+			    screen->tme_gtk_screen_mouse_label);
 
+#if GTK_MAJOR_VERSION == 4
+  motion=gtk_event_controller_motion_new();
+  gtk_widget_add_controller(screen->tme_gtk_screen_draw, motion);
+  event=gtk_event_controller_motion_new();
+  gtk_widget_add_controller(screen->tme_gtk_screen_mouse_label, event);
+  press = gtk_gesture_click_new();
+  gtk_widget_add_controller(screen->tme_gtk_screen_draw, GTK_EVENT_CONTROLLER (press));
+#elif GTK_MAJOR_VERSION == 3
+  motion=screen->motion=gtk_event_controller_motion_new(screen->tme_gtk_screen_draw);
+  event=screen->event=gtk_event_controller_motion_new(screen->tme_gtk_screen_mouse_label);
+  press=screen->press=gtk_gesture_multi_press_new(screen->tme_gtk_screen_draw);
+#endif
+  
+  gtk_gesture_single_set_button(GTK_GESTURE_SINGLE (press), 0);
   /* set the tip on the event box, which will eventually contain the mouse on label: */
-  gtk_widget_set_tooltip_text(ebox,
+  gtk_widget_set_tooltip_text(screen->tme_gtk_screen_mouse_label,
 			      "Press a key here to turn the mouse on.  The same key " \
 			      "will turn the mouse off.");
 
-  /* make sure the event box gets key_press events: */
-  gtk_widget_add_events(ebox, 
-			GDK_KEY_PRESS_MASK);
-
   /* set a signal handler for the event box events: */
-  g_signal_connect(ebox,
+  /*  g_signal_connect(ebox,
 		   "event",
 		   G_CALLBACK(_tme_gtk_mouse_ebox_event),
-		   screen);
-
-  /* the event box can focus: */
-  gtk_widget_set_can_focus(ebox, TRUE);
-
-  /* create the mouse on label: */
-  screen->tme_gtk_screen_mouse_label
-    = gtk_label_new(_("Mouse is off"));
-
-  /* add the mouse on label to the event box: */
-  gtk_container_add(GTK_CONTAINER(ebox), 
-		    screen->tme_gtk_screen_mouse_label);
+		   screen); */
 
   /* create the mouse statusbar: */
   screen->tme_gtk_screen_mouse_statusbar
@@ -298,20 +155,30 @@ _tme_gtk_mouse_attach(struct tme_gtk_screen *screen)
 		     screen->tme_gtk_screen_mouse_statusbar_cid,
 		     _("The Machine Emulator"));
   
+  /* on entering window, grab keyboard focus: */
+  g_signal_connect_swapped(motion,
+			   "enter",
+			   G_CALLBACK(gtk_widget_grab_focus),
+			   screen->tme_gtk_screen_draw);
+
   /* although the event mask doesn't include these events yet,
      set a signal handler for the mouse events: */
-  g_signal_connect(screen->tme_gtk_screen_draw,
-		   "motion_notify_event",
-		   G_CALLBACK(_tme_gtk_mouse_mouse_event), 
-		   screen->screen.tme_screen_display);
-  g_signal_connect(screen->tme_gtk_screen_draw,
-		   "button_press_event",
-		   G_CALLBACK(_tme_gtk_mouse_mouse_event), 
-		   screen->screen.tme_screen_display);
-  g_signal_connect(screen->tme_gtk_screen_draw,
-		   "button_release_event",
-		   G_CALLBACK(_tme_gtk_mouse_mouse_event), 
-		   screen->screen.tme_screen_display);
+  g_signal_connect(motion,
+		   "motion",
+		   G_CALLBACK(_tme_gtk_mouse_motion_event), 
+		   screen);
+
+  g_signal_connect(press, "released", G_CALLBACK(_tme_gtk_mouse_button_up),
+		   screen);
+
+  g_signal_connect(press, "pressed", G_CALLBACK(_tme_gtk_mouse_button_down),
+		   screen); 
+  
+  /* on entering window, grab keyboard focus: */
+  g_signal_connect_swapped(event,
+			   "enter",
+			   G_CALLBACK(gtk_widget_grab_focus),
+			   screen->tme_gtk_screen_mouse_label);
 
   /* 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
@@ -136,7 +136,17 @@ static enum rfbNewClientAction _tme_rfb_newclient(rfbClientPtr cl)
   return RFB_CLIENT_ACCEPT;
 }
 
-static struct tme_display *tme_rfb_display(rfbClientPtr cl) { return cl->clientData; }
+static void _tme_mouse_ev(int buttons, int x, int y, rfbClientPtr cl) { 
+  struct tme_display *display = cl->clientData;
+
+  /* make the buttons mask: */
+  display->tme_screen_mouse_buttons_last = buttons;
+  _tme_mouse_event(0,x,y,display);
+}
+
+static void _tme_keyboard_key_ev(int down, tme_keyboard_keyval_t key, rfbClientPtr cl) {
+  _tme_keyboard_key_event(down, key, cl->clientData);
+}
 
 /* the new RFB display function: */
 TME_ELEMENT_SUB_NEW_DECL(tme_host_rfb,display) {
@@ -148,8 +158,6 @@ TME_ELEMENT_SUB_NEW_DECL(tme_host_rfb,display) {
   /* start our data structure: */
   tme_display_init(element, 0);
 
-  _tme_display_get = tme_rfb_display;
-  
   /* recover our data structure: */
   display = element->tme_element_private;
 
@@ -165,8 +173,8 @@ TME_ELEMENT_SUB_NEW_DECL(tme_host_rfb,display) {
 					  display->tme_screen_height *
 					  bpp);
   server->alwaysShared = TRUE;
-  server->ptrAddEvent = _tme_mouse_buttons_event;
-  server->kbdAddEvent = _tme_keyboard_key_event;
+  server->ptrAddEvent = _tme_mouse_ev;
+  server->kbdAddEvent = _tme_keyboard_key_ev;
   server->newClientHook = _tme_rfb_newclient;
   //  server->httpDir = "../webclients";
   //  server->httpEnableProxyConnect = TRUE;