X-Git-Url: https://asedeno.scripts.mit.edu/gitweb/?a=blobdiff_plain;f=unix%2Fgtkwin.c;h=b1c86dd896aff5e5423f4a4146a402bcfacfa725;hb=a454399ec8d841e627d9d5e05ac977536e776754;hp=90e7d52b3218cab599a55090ca632912eb06a53d;hpb=a98b1cc03b4f6dd2d8fc42fd71008f113e484037;p=PuTTY.git

diff --git a/unix/gtkwin.c b/unix/gtkwin.c
index 90e7d52b..b1c86dd8 100644
--- a/unix/gtkwin.c
+++ b/unix/gtkwin.c
@@ -22,12 +22,6 @@
 #if !GTK_CHECK_VERSION(3,0,0)
 #include <gdk/gdkkeysyms.h>
 #endif
-#ifndef NOT_X_WINDOWS
-#include <gdk/gdkx.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xatom.h>
-#endif
 
 #if GTK_CHECK_VERSION(2,0,0)
 #include <gtk/gtkimmodule.h>
@@ -41,6 +35,14 @@
 #include "terminal.h"
 #include "gtkcompat.h"
 #include "gtkfont.h"
+#include "gtkmisc.h"
+
+#ifndef NOT_X_WINDOWS
+#include <gdk/gdkx.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#endif
 
 #define CAT2(x,y) x ## y
 #define CAT(x,y) CAT2(x,y)
@@ -72,6 +74,8 @@ extern int use_pty_argv;
  */
 static guint timer_id = 0;
 
+struct clipboard_data_instance;
+
 struct gui_data {
     GtkWidget *window, *area, *sbar;
     GtkBox *hbox;
@@ -80,8 +84,33 @@ struct gui_data {
 	*restartitem;
     GtkWidget *sessionsmenu;
 #ifndef NO_BACKING_PIXMAPS
+    /*
+     * Server-side pixmap which we use to cache the terminal window's
+     * contents. When we draw text in the terminal, we draw it to this
+     * pixmap first, and then blit from there to the actual window;
+     * this way, X expose events can be handled with an absolute
+     * minimum of network traffic, by just sending a command to
+     * re-blit an appropriate rectangle from this pixmap.
+     */
     GdkPixmap *pixmap;
 #endif
+#ifdef DRAW_TEXT_CAIRO
+    /*
+     * If we're drawing using Cairo, we cache the same image on the
+     * client side in a Cairo surface.
+     *
+     * In GTK2+Cairo, this happens _as well_ as having the server-side
+     * pixmap cache above; in GTK3+Cairo, server-side pixmaps are
+     * deprecated, so we _just_ have this client-side cache. In the
+     * latter case that means we have to transmit a big wodge of
+     * bitmap data over the X connection on every expose event; but
+     * GTK3 apparently deliberately provides no way to avoid that
+     * inefficiency, and at least this way we don't _also_ have to
+     * redo any font rendering just because the window was temporarily
+     * covered.
+     */
+    cairo_surface_t *surface;
+#endif
 #if GTK_CHECK_VERSION(2,0,0)
     GtkIMContext *imc;
 #endif
@@ -96,11 +125,16 @@ struct gui_data {
 #if !GTK_CHECK_VERSION(3,0,0)
     GdkColormap *colmap;
 #endif
-    wchar_t *pastein_data;
     int direct_to_font;
+    wchar_t *pastein_data;
     int pastein_data_len;
+#ifdef JUST_USE_GTK_CLIPBOARD_UTF8
+    GtkClipboard *clipboard;
+    struct clipboard_data_instance *current_cdi;
+#else
     char *pasteout_data, *pasteout_data_ctext, *pasteout_data_utf8;
     int pasteout_data_len, pasteout_data_ctext_len, pasteout_data_utf8_len;
+#endif
     int font_width, font_height;
     int width, height;
     int ignore_sbar;
@@ -126,11 +160,15 @@ struct gui_data {
     int ngtkargs;
     guint32 input_event_time; /* Timestamp of the most recent input event. */
     int reconfiguring;
+#if GTK_CHECK_VERSION(3,4,0)
+    gdouble cumulative_scroll;
+#endif
     /* Cached things out of conf that we refer to a lot */
     int bold_style;
     int window_border;
     int cursor_type;
     int drawtype;
+    int meta_mod_mask;
 };
 
 static void cache_conf_values(struct gui_data *inst)
@@ -138,6 +176,15 @@ static void cache_conf_values(struct gui_data *inst)
     inst->bold_style = conf_get_int(inst->conf, CONF_bold_style);
     inst->window_border = conf_get_int(inst->conf, CONF_window_border);
     inst->cursor_type = conf_get_int(inst->conf, CONF_cursor_type);
+#ifdef OSX_META_KEY_CONFIG
+    inst->meta_mod_mask = 0;
+    if (conf_get_int(inst->conf, CONF_osx_option_meta))
+        inst->meta_mod_mask |= GDK_MOD1_MASK;
+    if (conf_get_int(inst->conf, CONF_osx_command_meta))
+        inst->meta_mod_mask |= GDK_MOD2_MASK;
+#else
+    inst->meta_mod_mask = GDK_MOD1_MASK;
+#endif
 }
 
 struct draw_ctx {
@@ -183,7 +230,7 @@ void connection_fatal(void *frontend, const char *p, ...)
 FontSpec *platform_default_fontspec(const char *name)
 {
     if (!strcmp(name, "Font"))
-	return fontspec_new("server:fixed");
+	return fontspec_new(DEFAULT_GTK_FONT);
     else
         return fontspec_new("");
 }
@@ -496,16 +543,30 @@ gint configure_area(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
 	need_size = 1;
     }
 
+    {
+        int backing_w = w * inst->font_width + 2*inst->window_border;
+        int backing_h = h * inst->font_height + 2*inst->window_border;
+
 #ifndef NO_BACKING_PIXMAPS
-    if (inst->pixmap) {
-	gdk_pixmap_unref(inst->pixmap);
-	inst->pixmap = NULL;
-    }
+        if (inst->pixmap) {
+            gdk_pixmap_unref(inst->pixmap);
+            inst->pixmap = NULL;
+        }
+
+        inst->pixmap = gdk_pixmap_new(gtk_widget_get_window(widget),
+                                      backing_w, backing_h, -1);
+#endif
+
+#ifdef DRAW_TEXT_CAIRO
+        if (inst->surface) {
+            cairo_surface_destroy(inst->surface);
+            inst->surface = NULL;
+        }
 
-    inst->pixmap = gdk_pixmap_new(gtk_widget_get_window(widget),
-				  (w * inst->font_width + 2*inst->window_border),
-				  (h * inst->font_height + 2*inst->window_border), -1);
+        inst->surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24,
+                                                   backing_w, backing_h);
 #endif
+    }
 
     draw_backing_rect(inst);
 
@@ -544,40 +605,21 @@ static gint draw_area(GtkWidget *widget, cairo_t *cr, gpointer data)
 {
     struct gui_data *inst = (struct gui_data *)data;
 
-    if (inst->term) {
-        struct draw_ctx adctx, *dctx = &adctx;
+    /*
+     * GTK3 window redraw: we always expect Cairo to be enabled, so
+     * that inst->surface exists, and pixmaps to be disabled, so that
+     * inst->pixmap does not exist. Hence, we just blit from
+     * inst->surface to the window.
+     */
+    if (inst->surface) {
         GdkRectangle dirtyrect;
 
-        dctx->inst = inst;
-        dctx->uctx.type = DRAWTYPE_CAIRO;
-        dctx->uctx.u.cairo.widget = widget;
-        dctx->uctx.u.cairo.cr = cr;
-        cairo_setup_dctx(dctx);
-
         gdk_cairo_get_clip_rectangle(cr, &dirtyrect);
 
-        /*
-         * As in window.c, we clear the 'immediately' flag in the
-         * term_paint() call if the terminal has an update pending, in
-         * case we're constrained within this event to only draw on
-         * the exposed rectangle of the window. (Because if the whole
-         * of a character cell needs a redraw due to a terminal
-         * contents change, the last thing we want is to give it a
-         * _partial_ redraw here due to system-imposed clipping, and
-         * then have the next main terminal update believe it's been
-         * redrawn in full.)
-         *
-         * I don't actually know if GTK draw events will constrain us
-         * in this way, but it's best to be careful...
-         */
-        term_paint(inst->term, dctx,
-                   (dirtyrect.x - inst->window_border) / inst->font_width,
-                   (dirtyrect.y - inst->window_border) / inst->font_height,
-                   (dirtyrect.x + dirtyrect.width -
-                    inst->window_border) / inst->font_width,
-                   (dirtyrect.y + dirtyrect.height -
-                    inst->window_border) / inst->font_height,
-                   !inst->term->window_update_pending);
+        cairo_set_source_surface(cr, inst->surface, 0, 0);
+        cairo_rectangle(cr, dirtyrect.x, dirtyrect.y,
+                        dirtyrect.width, dirtyrect.height);
+        cairo_fill(cr);
     }
 
     return TRUE;
@@ -589,8 +631,8 @@ gint expose_area(GtkWidget *widget, GdkEventExpose *event, gpointer data)
 
 #ifndef NO_BACKING_PIXMAPS
     /*
-     * Pass the exposed rectangle to terminal.c, which will call us
-     * back to do the actual painting.
+     * Draw to the exposed part of the window from the server-side
+     * backing pixmap.
      */
     if (inst->pixmap) {
 	gdk_draw_pixmap(gtk_widget_get_window(widget),
@@ -602,17 +644,18 @@ gint expose_area(GtkWidget *widget, GdkEventExpose *event, gpointer data)
 			event->area.width, event->area.height);
     }
 #else
-    if (inst->term) {
-        Context ctx = get_ctx(inst);
-        term_paint(inst->term, ctx,
-                   (event->area.x - inst->window_border) / inst->font_width,
-                   (event->area.y - inst->window_border) / inst->font_height,
-                   (event->area.x + event->area.width -
-                    inst->window_border) / inst->font_width,
-                   (event->area.y + event->area.height -
-                    inst->window_border) / inst->font_height,
-                   !inst->term->window_update_pending);
-        free_ctx(ctx);
+    /*
+     * Failing that, draw from the client-side Cairo surface. (We
+     * should never be compiled in a context where we have _neither_
+     * inst->surface nor inst->pixmap.)
+     */
+    if (inst->surface) {
+        cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget));
+        cairo_set_source_surface(cr, inst->surface, 0, 0);
+        cairo_rectangle(cr, event->area.x, event->area.y,
+			event->area.width, event->area.height);
+        cairo_fill(cr);
+        cairo_destroy(cr);
     }
 #endif
 
@@ -623,6 +666,17 @@ gint expose_area(GtkWidget *widget, GdkEventExpose *event, gpointer data)
 #define KEY_PRESSED(k) \
     (inst->keystate[(k) / 32] & (1 << ((k) % 32)))
 
+#ifdef KEY_EVENT_DIAGNOSTICS
+char *dup_keyval_name(guint keyval)
+{
+    const char *name = gdk_keyval_name(keyval);
+    if (name)
+        return dupstr(name);
+    else
+        return dupprintf("UNKNOWN[%u]", (unsigned)keyval);
+}
+#endif
+
 gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 {
     struct gui_data *inst = (struct gui_data *)data;
@@ -639,6 +693,85 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
     special = use_ucsoutput = FALSE;
     output_charset = CS_ISO8859_1;
 
+#ifdef KEY_EVENT_DIAGNOSTICS
+    {
+        char *type_string, *state_string, *keyval_string, *string_string;
+
+        type_string = (event->type == GDK_KEY_PRESS ? dupstr("PRESS") :
+                       event->type == GDK_KEY_RELEASE ? dupstr("RELEASE") :
+                       dupprintf("UNKNOWN[%d]", (int)event->type));
+
+        {
+            static const struct {
+                int mod_bit;
+                const char *name;
+            } mod_bits[] = {
+                {GDK_SHIFT_MASK, "SHIFT"},
+                {GDK_LOCK_MASK, "LOCK"},
+                {GDK_CONTROL_MASK, "CONTROL"},
+                {GDK_MOD1_MASK, "MOD1"},
+                {GDK_MOD2_MASK, "MOD2"},
+                {GDK_MOD3_MASK, "MOD3"},
+                {GDK_MOD4_MASK, "MOD4"},
+                {GDK_MOD5_MASK, "MOD5"},
+                {GDK_SUPER_MASK, "SUPER"},
+                {GDK_HYPER_MASK, "HYPER"},
+                {GDK_META_MASK, "META"},
+            };
+            int i;
+            int val = event->state;
+
+            state_string = dupstr("");
+
+            for (i = 0; i < lenof(mod_bits); i++) {
+                if (val & mod_bits[i].mod_bit) {
+                    char *old = state_string;
+                    state_string = dupcat(state_string,
+                                          state_string[0] ? "|" : "",
+                                          mod_bits[i].name,
+                                          (char *)NULL);
+                    sfree(old);
+
+                    val &= ~mod_bits[i].mod_bit;
+                }
+            }
+
+            if (val || !state_string[0]) {
+                char *old = state_string;
+                state_string = dupprintf("%s%s%d", state_string,
+                                         state_string[0] ? "|" : "", val);
+                sfree(old);
+            }
+        }
+
+        keyval_string = dup_keyval_name(event->keyval);
+
+        string_string = dupstr("");
+        {
+            int i;
+            for (i = 0; event->string[i]; i++) {
+                char *old = string_string;
+                string_string = dupprintf("%s%s%02x", string_string,
+                                          string_string[0] ? " " : "",
+                                          (unsigned)event->string[i] & 0xFF);
+                sfree(old);
+            }
+        }
+
+        debug(("key_event: type=%s keyval=%s state=%s "
+               "hardware_keycode=%d is_modifier=%s string=[%s]\n",
+               type_string, keyval_string, state_string,
+               (int)event->hardware_keycode,
+               event->is_modifier ? "TRUE" : "FALSE",
+               string_string));
+
+        sfree(type_string);
+        sfree(state_string);
+        sfree(keyval_string);
+        sfree(string_string);
+    }
+#endif /* KEY_EVENT_DIAGNOSTICS */
+
     /*
      * If Alt is being released after typing an Alt+numberpad
      * sequence, we should generate the code that was typed.
@@ -655,8 +788,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
              event->keyval == GDK_KEY_Alt_L ||
              event->keyval == GDK_KEY_Alt_R) &&
             inst->alt_keycode >= 0 && inst->alt_digits > 1) {
-#ifdef KEY_DEBUGGING
-            printf("Alt key up, keycode = %d\n", inst->alt_keycode);
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - modifier release terminates Alt+numberpad input, "
+                   "keycode = %d\n", inst->alt_keycode));
 #endif
             /*
              * FIXME: we might usefully try to do something clever here
@@ -668,27 +802,23 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
             goto done;
         }
 #if GTK_CHECK_VERSION(2,0,0)
-        if (gtk_im_context_filter_keypress(inst->imc, event))
+#ifdef KEY_EVENT_DIAGNOSTICS
+        debug((" - key release, passing to IM\n"));
+#endif
+        if (gtk_im_context_filter_keypress(inst->imc, event)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - key release accepted by IM\n"));
+#endif
             return TRUE;
+        } else {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - key release not accepted by IM\n"));
+#endif
+        }
 #endif
     }
 
     if (event->type == GDK_KEY_PRESS) {
-#ifdef KEY_DEBUGGING
-	{
-	    int i;
-	    printf("keypress: keyval = %04x, state = %08x; string =",
-		   event->keyval, event->state);
-	    for (i = 0; event->string[i]; i++)
-		printf(" %02x", (unsigned char) event->string[i]);
-	    printf("\n");
-	}
-#endif
-
-	/*
-	 * NYI: Compose key (!!! requires Unicode faff before even trying)
-	 */
-
 	/*
 	 * If Alt has just been pressed, we start potentially
 	 * accumulating an Alt+numberpad code. We do this by
@@ -698,18 +828,22 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	     event->keyval == GDK_KEY_Meta_R ||
              event->keyval == GDK_KEY_Alt_L ||
              event->keyval == GDK_KEY_Alt_R)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - modifier press potentially begins Alt+numberpad "
+                   "input\n"));
+#endif
 	    inst->alt_keycode = -1;
             inst->alt_digits = 0;
 	    goto done;		       /* this generates nothing else */
 	}
 
 	/*
-	 * If we're seeing a numberpad key press with Mod1 down,
+	 * If we're seeing a numberpad key press with Meta down,
 	 * consider adding it to alt_keycode if that's sensible.
-	 * Anything _else_ with Mod1 down cancels any possibility
+	 * Anything _else_ with Meta down cancels any possibility
 	 * of an ALT keycode: we set alt_keycode to -2.
 	 */
-	if ((event->state & GDK_MOD1_MASK) && inst->alt_keycode != -2) {
+	if ((event->state & inst->meta_mod_mask) && inst->alt_keycode != -2) {
 	    int digit = -1;
 	    switch (event->keyval) {
 	      case GDK_KEY_KP_0: case GDK_KEY_KP_Insert: digit = 0; break;
@@ -726,17 +860,17 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	    if (digit < 0)
 		inst->alt_keycode = -2;   /* it's invalid */
 	    else {
-#ifdef KEY_DEBUGGING
-		printf("Adding digit %d to keycode %d", digit,
-		       inst->alt_keycode);
+#ifdef KEY_EVENT_DIAGNOSTICS
+                int old_keycode = inst->alt_keycode;
 #endif
 		if (inst->alt_keycode == -1)
 		    inst->alt_keycode = digit;   /* one-digit code */
 		else
 		    inst->alt_keycode = inst->alt_keycode * 10 + digit;
                 inst->alt_digits++;
-#ifdef KEY_DEBUGGING
-		printf(" gives new code %d\n", inst->alt_keycode);
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - Alt+numberpad digit %d added to keycode %d"
+                       " gives %d\n", digit, old_keycode, inst->alt_keycode));
 #endif
 		/* Having used this digit, we now do nothing more with it. */
 		goto done;
@@ -749,21 +883,33 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	 */
 	if (event->keyval == GDK_KEY_Page_Up &&
             (event->state & GDK_SHIFT_MASK)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Shift-PgUp scroll\n"));
+#endif
 	    term_scroll(inst->term, 0, -inst->height/2);
 	    return TRUE;
 	}
 	if (event->keyval == GDK_KEY_Page_Up &&
             (event->state & GDK_CONTROL_MASK)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Ctrl-PgUp scroll\n"));
+#endif
 	    term_scroll(inst->term, 0, -1);
 	    return TRUE;
 	}
 	if (event->keyval == GDK_KEY_Page_Down &&
             (event->state & GDK_SHIFT_MASK)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Shift-PgDn scroll\n"));
+#endif
 	    term_scroll(inst->term, 0, +inst->height/2);
 	    return TRUE;
 	}
 	if (event->keyval == GDK_KEY_Page_Down &&
             (event->state & GDK_CONTROL_MASK)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Ctrl-PgDn scroll\n"));
+#endif
 	    term_scroll(inst->term, 0, +1);
 	    return TRUE;
 	}
@@ -773,6 +919,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	 */
 	if (event->keyval == GDK_KEY_Insert &&
             (event->state & GDK_SHIFT_MASK)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Shift-Insert paste\n"));
+#endif
 	    request_paste(inst);
 	    return TRUE;
 	}
@@ -796,7 +945,7 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	 */
 	output_charset = CS_ISO8859_1;
 	strncpy(output+1, event->string, lenof(output)-1);
-#else
+#else /* !GTK_CHECK_VERSION(2,0,0) */
         /*
          * Most things can now be passed to
          * gtk_im_context_filter_keypress without breaking anything
@@ -856,8 +1005,40 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
                     event->keyval == GDK_KEY_KP_Page_Up)) {
             /* nethack mode; do nothing */
         } else {
-            if (gtk_im_context_filter_keypress(inst->imc, event))
-                return TRUE;
+            int try_filter = TRUE;
+
+#ifdef META_MANUAL_MASK
+            if (event->state & META_MANUAL_MASK & inst->meta_mod_mask) {
+                /*
+                 * If this key event had a Meta modifier bit set which
+                 * is also in META_MANUAL_MASK, that means passing
+                 * such an event to the GtkIMContext will be unhelpful
+                 * (it will eat the keystroke and turn it into
+                 * something not what we wanted).
+                 */
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - Meta modifier requiring manual intervention, "
+                       "suppressing IM filtering\n"));
+#endif
+                try_filter = FALSE;
+            }
+#endif
+
+            if (try_filter) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - general key press, passing to IM\n"));
+#endif
+                if (gtk_im_context_filter_keypress(inst->imc, event)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                    debug((" - key press accepted by IM\n"));
+#endif
+                    return TRUE;
+                } else {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                    debug((" - key press not accepted by IM\n"));
+#endif
+                }
+            }
         }
 
 	/*
@@ -883,40 +1064,162 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 			    event->string, strlen(event->string),
 			    widedata, lenof(widedata)-1);
 
+#ifdef KEY_EVENT_DIAGNOSTICS
+            {
+                char *string_string = dupstr("");
+                int i;
+
+                for (i = 0; i < wlen; i++) {
+                    char *old = string_string;
+                    string_string = dupprintf("%s%s%04x", string_string,
+                                              string_string[0] ? " " : "",
+                                              (unsigned)widedata[i]);
+                    sfree(old);
+                }
+                debug((" - string translated into Unicode = [%s]\n",
+                       string_string));
+                sfree(string_string);
+            }
+#endif
+
 	    wp = widedata;
 	    ulen = charset_from_unicode(&wp, &wlen, output+1, lenof(output)-2,
 					CS_UTF8, NULL, NULL, 0);
+
+#ifdef KEY_EVENT_DIAGNOSTICS
+            {
+                char *string_string = dupstr("");
+                int i;
+
+                for (i = 0; i < ulen; i++) {
+                    char *old = string_string;
+                    string_string = dupprintf("%s%s%02x", string_string,
+                                              string_string[0] ? " " : "",
+                                              (unsigned)output[i+1] & 0xFF);
+                    sfree(old);
+                }
+                debug((" - string translated into UTF-8 = [%s]\n",
+                       string_string));
+                sfree(string_string);
+            }
+#endif
+
 	    output[1+ulen] = '\0';
 	}
-#endif
+#endif /* !GTK_CHECK_VERSION(2,0,0) */
 
 	if (!output[1] &&
 	    (ucsval = keysym_to_unicode(event->keyval)) >= 0) {
 	    ucsoutput[0] = '\033';
 	    ucsoutput[1] = ucsval;
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - keysym_to_unicode gave %04x\n",
+                   (unsigned)ucsoutput[1]));
+#endif
 	    use_ucsoutput = TRUE;
 	    end = 2;
 	} else {
 	    output[lenof(output)-1] = '\0';
 	    end = strlen(output);
 	}
-	if (event->state & GDK_MOD1_MASK) {
+	if (event->state & inst->meta_mod_mask) {
 	    start = 0;
 	    if (end == 1) end = 0;
+
+#ifdef META_MANUAL_MASK
+            if (event->state & META_MANUAL_MASK) {
+                /*
+                 * Key events which have a META_MANUAL_MASK meta bit
+                 * set may have a keyval reflecting that, e.g. on OS X
+                 * the Option key acts as an AltGr-like modifier and
+                 * causes different Unicode characters to be output.
+                 *
+                 * To work around this, we clear the dangerous
+                 * modifier bit and retranslate from the hardware
+                 * keycode as if the key had been pressed without that
+                 * modifier. Then we prefix Esc to *that*.
+                 */
+                guint new_keyval;
+                GdkModifierType consumed;
+                if (gdk_keymap_translate_keyboard_state
+                    (gdk_keymap_get_for_display(gdk_display_get_default()),
+                     event->hardware_keycode, event->state & ~META_MANUAL_MASK,
+                     0, &new_keyval, NULL, NULL, &consumed)) {
+                    ucsoutput[0] = '\033';
+                    ucsoutput[1] = gdk_keyval_to_unicode(new_keyval);
+#ifdef KEY_EVENT_DIAGNOSTICS
+                    {
+                        char *keyval_name = dup_keyval_name(new_keyval);
+                        debug((" - retranslation for manual Meta: "
+                               "new keyval = %s, Unicode = %04x\n",
+                               keyval_name, (unsigned)ucsoutput[1]));
+                        sfree(keyval_name);
+                    }
+#endif
+                    use_ucsoutput = TRUE;
+                    end = 2;
+                }
+            }
+#endif
 	} else
 	    start = 1;
 
 	/* Control-` is the same as Control-\ (unless gtk has a better idea) */
 	if (!output[1] && event->keyval == '`' &&
 	    (event->state & GDK_CONTROL_MASK)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Ctrl-` special case, translating as 1c\n"));
+#endif
 	    output[1] = '\x1C';
 	    use_ucsoutput = FALSE;
 	    end = 2;
 	}
 
+        /* Some GTK backends (e.g. Quartz) do not change event->string
+         * in response to the Control modifier. So we do it ourselves
+         * here, if it's not already happened.
+         *
+         * The translations below are in line with X11 policy as far
+         * as I know. */
+        if ((event->state & GDK_CONTROL_MASK) && end == 2) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            int orig = output[1];
+#endif
+
+            if (output[1] >= '3' && output[1] <= '7') {
+                /* ^3,...,^7 map to 0x1B,...,0x1F */
+                output[1] += '\x1B' - '3';
+            } else if (output[1] == '2' || output[1] == ' ') {
+                /* ^2 and ^Space are both ^@, i.e. \0 */
+                output[1] = '\0';
+            } else if (output[1] == '8') {
+                /* ^8 is DEL */
+                output[1] = '\x7F';
+            } else if (output[1] == '/') {
+                /* ^/ is the same as ^_ */
+                output[1] = '\x1F';
+            } else if (output[1] >= 0x40 && output[1] < 0x7F) {
+                /* Everything anywhere near the alphabetics just gets
+                 * masked. */
+                output[1] &= 0x1F;
+            }
+            /* Anything else, e.g. '0', is unchanged. */
+
+#ifdef KEY_EVENT_DIAGNOSTICS
+            if (orig == output[1])
+                debug((" - manual Ctrl key handling did nothing\n"));
+            else
+                debug((" - manual Ctrl key handling: %02x -> %02x\n",
+                       (unsigned)orig, (unsigned)output[1]));
+#endif
+        }
+
 	/* Control-Break sends a Break special to the backend */
 	if (event->keyval == GDK_KEY_Break &&
 	    (event->state & GDK_CONTROL_MASK)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Ctrl-Break special case, sending TS_BRK\n"));
+#endif
 	    if (inst->back)
 		inst->back->special(inst->backhandle, TS_BRK);
 	    return TRUE;
@@ -925,6 +1228,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	/* We handle Return ourselves, because it needs to be flagged as
 	 * special to ldisc. */
 	if (event->keyval == GDK_KEY_Return) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Return special case, translating as 0d + special\n"));
+#endif
 	    output[1] = '\015';
 	    use_ucsoutput = FALSE;
 	    end = 2;
@@ -937,6 +1243,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	     event->keyval == '@') &&
 	    (event->state & (GDK_SHIFT_MASK |
 			     GDK_CONTROL_MASK)) == GDK_CONTROL_MASK) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Ctrl-{space,2,@} special case, translating as 00\n"));
+#endif
 	    output[1] = '\0';
 	    use_ucsoutput = FALSE;
 	    end = 2;
@@ -946,6 +1255,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	if (!output[1] && event->keyval == ' ' &&
 	    (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) ==
 	    (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Ctrl-Shift-space special case, translating as 00a0\n"));
+#endif
 	    output[1] = '\240';
 	    output_charset = CS_ISO8859_1;
 	    use_ucsoutput = FALSE;
@@ -957,6 +1269,10 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	    !(event->state & GDK_SHIFT_MASK)) {
 	    output[1] = conf_get_int(inst->conf, CONF_bksp_is_delete) ?
 		'\x7F' : '\x08';
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Backspace, translating as %02x\n",
+                   (unsigned)output[1]));
+#endif
 	    use_ucsoutput = FALSE;
 	    end = 2;
 	    special = TRUE;
@@ -966,6 +1282,10 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	    (event->state & GDK_SHIFT_MASK)) {
 	    output[1] = conf_get_int(inst->conf, CONF_bksp_is_delete) ?
 		'\x08' : '\x7F';
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Shift-Backspace, translating as %02x\n",
+                   (unsigned)output[1]));
+#endif
 	    use_ucsoutput = FALSE;
 	    end = 2;
 	    special = TRUE;
@@ -975,6 +1295,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	if (event->keyval == GDK_KEY_ISO_Left_Tab ||
 	    (event->keyval == GDK_KEY_Tab &&
              (event->state & GDK_SHIFT_MASK))) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Shift-Tab, translating as ESC [ Z\n"));
+#endif
 	    end = 1 + sprintf(output+1, "\033[Z");
 	    use_ucsoutput = FALSE;
 	}
@@ -982,6 +1305,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	 * (Curiously, at least one version of the MacOS 10.5 X server
 	 * doesn't translate Tab for us. */
 	if (event->keyval == GDK_KEY_Tab && end <= 1) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            debug((" - Tab, translating as 09\n"));
+#endif
 	    output[1] = '\t';
 	    end = 2;
 	}
@@ -1019,6 +1345,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 		    output[1] = keys[1];
 		else
 		    output[1] = keys[0];
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - Nethack-mode key"));
+#endif
 		use_ucsoutput = FALSE;
 		goto done;
 	    }
@@ -1074,6 +1403,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 		} else
 		    end = 1 + sprintf(output+1, "\033O%c", xkey);
 		use_ucsoutput = FALSE;
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - Application keypad mode key"));
+#endif
 		goto done;
 	    }
 	}
@@ -1178,6 +1510,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 
 	    if (inst->term->vt52_mode && code > 0 && code <= 6) {
 		end = 1 + sprintf(output+1, "\x1B%c", " HLMEIG"[code]);
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - VT52 mode small keypad key"));
+#endif
 		use_ucsoutput = FALSE;
 		goto done;
 	    }
@@ -1203,6 +1538,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 		if (event->state & GDK_SHIFT_MASK) index += 12;
 		if (event->state & GDK_CONTROL_MASK) index += 24;
 		end = 1 + sprintf(output+1, "\x1B[%c", codes[index]);
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - SCO mode function key"));
+#endif
 		use_ucsoutput = FALSE;
 		goto done;
 	    }
@@ -1215,6 +1553,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 		} else {
 		    end = 1 + sprintf(output+1, "\x1B[%c", codes[code-1]);
 		}
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - SCO mode small keypad key"));
+#endif
 		use_ucsoutput = FALSE;
 		goto done;
 	    }
@@ -1225,35 +1566,59 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 		    offt++;
 		if (code > 21)
 		    offt++;
-		if (inst->term->vt52_mode)
+		if (inst->term->vt52_mode) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                    debug((" - VT52 mode function key"));
+#endif
 		    end = 1 + sprintf(output+1,
 				      "\x1B%c", code + 'P' - 11 - offt);
-		else
+                } else {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                    debug((" - VT100+ mode function key"));
+#endif
 		    end = 1 + sprintf(output+1,
 				      "\x1BO%c", code + 'P' - 11 - offt);
+                }
 		use_ucsoutput = FALSE;
 		goto done;
 	    }
 	    if (funky_type == FUNKY_LINUX && code >= 11 && code <= 15) {
 		end = 1 + sprintf(output+1, "\x1B[[%c", code + 'A' - 11);
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - Linux mode F1-F5 function key"));
+#endif
 		use_ucsoutput = FALSE;
 		goto done;
 	    }
 	    if (funky_type == FUNKY_XTERM && code >= 11 && code <= 14) {
-		if (inst->term->vt52_mode)
+		if (inst->term->vt52_mode) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                    debug((" - VT52 mode (overriding xterm) F1-F4 function"
+                           " key"));
+#endif
 		    end = 1 + sprintf(output+1, "\x1B%c", code + 'P' - 11);
-		else
+                } else {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                    debug((" - xterm mode F1-F4 function key"));
+#endif
 		    end = 1 + sprintf(output+1, "\x1BO%c", code + 'P' - 11);
+                }
 		use_ucsoutput = FALSE;
 		goto done;
 	    }
 	    if ((code == 1 || code == 4) &&
 		conf_get_int(inst->conf, CONF_rxvt_homeend)) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - rxvt style Home/End"));
+#endif
 		end = 1 + sprintf(output+1, code == 1 ? "\x1B[H" : "\x1BOw");
 		use_ucsoutput = FALSE;
 		goto done;
 	    }
 	    if (code) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - ordinary function key encoding"));
+#endif
 		end = 1 + sprintf(output+1, "\x1B[%d~", code);
 		use_ucsoutput = FALSE;
 		goto done;
@@ -1279,6 +1644,9 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	    if (xkey) {
 		end = 1 + format_arrow_key(output+1, inst->term, xkey,
 					   event->state & GDK_CONTROL_MASK);
+#ifdef KEY_EVENT_DIAGNOSTICS
+                debug((" - arrow key"));
+#endif
 		use_ucsoutput = FALSE;
 		goto done;
 	    }
@@ -1289,15 +1657,22 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
     done:
 
     if (end-start > 0) {
-#ifdef KEY_DEBUGGING
-	int i;
-	printf("generating sequence:");
-	for (i = start; i < end; i++)
-	    printf(" %02x", (unsigned char) output[i]);
-	printf("\n");
-#endif
-
 	if (special) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+            char *string_string = dupstr("");
+            int i;
+
+            for (i = start; i < end; i++) {
+                char *old = string_string;
+                string_string = dupprintf("%s%s%02x", string_string,
+                                          string_string[0] ? " " : "",
+                                          (unsigned)output[i] & 0xFF);
+                sfree(old);
+            }
+            debug((" - final output, special, generic encoding = [%s]\n",
+                   charset_to_localenc(output_charset), string_string));
+            sfree(string_string);
+#endif
 	    /*
 	     * For special control characters, the character set
 	     * should never matter.
@@ -1307,10 +1682,41 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 		ldisc_send(inst->ldisc, output+start, -2, 1);
 	} else if (!inst->direct_to_font) {
 	    if (!use_ucsoutput) {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                char *string_string = dupstr("");
+                int i;
+
+                for (i = start; i < end; i++) {
+                    char *old = string_string;
+                    string_string = dupprintf("%s%s%02x", string_string,
+                                              string_string[0] ? " " : "",
+                                              (unsigned)output[i] & 0xFF);
+                    sfree(old);
+                }
+                debug((" - final output in %s = [%s]\n",
+                       charset_to_localenc(output_charset), string_string));
+                sfree(string_string);
+#endif
 		if (inst->ldisc)
 		    lpage_send(inst->ldisc, output_charset, output+start,
 			       end-start, 1);
 	    } else {
+#ifdef KEY_EVENT_DIAGNOSTICS
+                char *string_string = dupstr("");
+                int i;
+
+                for (i = start; i < end; i++) {
+                    char *old = string_string;
+                    string_string = dupprintf("%s%s%04x", string_string,
+                                              string_string[0] ? " " : "",
+                                              (unsigned)ucsoutput[i]);
+                    sfree(old);
+                }
+                debug((" - final output in Unicode = [%s]\n",
+                       string_string));
+                sfree(string_string);
+#endif
+
 		/*
 		 * We generated our own Unicode key data from the
 		 * keysym, so use that instead.
@@ -1323,6 +1729,21 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 	     * In direct-to-font mode, we just send the string
 	     * exactly as we received it.
 	     */
+#ifdef KEY_EVENT_DIAGNOSTICS
+            char *string_string = dupstr("");
+            int i;
+
+            for (i = start; i < end; i++) {
+                char *old = string_string;
+                string_string = dupprintf("%s%s%02x", string_string,
+                                          string_string[0] ? " " : "",
+                                          (unsigned)output[i] & 0xFF);
+                sfree(old);
+            }
+            debug((" - final output in direct-to-font encoding = [%s]\n",
+                   string_string));
+            sfree(string_string);
+#endif
 	    if (inst->ldisc)
 		ldisc_send(inst->ldisc, output+start, end-start, 1);
 	}
@@ -1338,6 +1759,22 @@ gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
 void input_method_commit_event(GtkIMContext *imc, gchar *str, gpointer data)
 {
     struct gui_data *inst = (struct gui_data *)data;
+
+#ifdef KEY_EVENT_DIAGNOSTICS
+    char *string_string = dupstr("");
+    int i;
+
+    for (i = 0; str[i]; i++) {
+        char *old = string_string;
+        string_string = dupprintf("%s%s%02x", string_string,
+                                  string_string[0] ? " " : "",
+                                  (unsigned)str[i] & 0xFF);
+        sfree(old);
+    }
+    debug((" - IM commit event in UTF-8 = [%s]\n", string_string));
+    sfree(string_string);
+#endif
+
     if (inst->ldisc)
         lpage_send(inst->ldisc, CS_UTF8, str, strlen(str), 1);
     show_mouseptr(inst, 0);
@@ -1345,6 +1782,61 @@ void input_method_commit_event(GtkIMContext *imc, gchar *str, gpointer data)
 }
 #endif
 
+#define SCROLL_INCREMENT_LINES 5
+
+#if GTK_CHECK_VERSION(3,4,0)
+gboolean scroll_internal(struct gui_data *inst, gdouble delta, guint state,
+			 gdouble ex, gdouble ey)
+{
+    int shift, ctrl, alt, x, y, raw_mouse_mode;
+
+    show_mouseptr(inst, 1);
+
+    shift = state & GDK_SHIFT_MASK;
+    ctrl = state & GDK_CONTROL_MASK;
+    alt = state & inst->meta_mod_mask;
+
+    x = (ex - inst->window_border) / inst->font_width;
+    y = (ey - inst->window_border) / inst->font_height;
+
+    raw_mouse_mode =
+        send_raw_mouse && !(shift && conf_get_int(inst->conf,
+                                                  CONF_mouse_override));
+
+    inst->cumulative_scroll += delta * SCROLL_INCREMENT_LINES;
+
+    if (!raw_mouse_mode) {
+        int scroll_lines = (int)inst->cumulative_scroll; /* rounds toward 0 */
+        if (scroll_lines) {
+            term_scroll(inst->term, 0, scroll_lines);
+            inst->cumulative_scroll -= scroll_lines;
+        }
+        return TRUE;
+    } else {
+        int scroll_events = (int)(inst->cumulative_scroll /
+                                  SCROLL_INCREMENT_LINES);
+        if (scroll_events) {
+            int button;
+
+            inst->cumulative_scroll -= scroll_events * SCROLL_INCREMENT_LINES;
+
+            if (scroll_events > 0) {
+                button = MBT_WHEEL_DOWN;
+            } else {
+                button = MBT_WHEEL_UP;
+                scroll_events = -scroll_events;
+            }
+
+            while (scroll_events-- > 0) {
+                term_mouse(inst->term, button, translate_button(button),
+                           MA_CLICK, x, y, shift, ctrl, alt);
+            }
+        }
+        return TRUE;
+    }
+}
+#endif
+
 gboolean button_internal(struct gui_data *inst, guint32 timestamp,
 			 GdkEventType type, guint ebutton, guint state,
 			 gdouble ex, gdouble ey)
@@ -1358,7 +1850,7 @@ gboolean button_internal(struct gui_data *inst, guint32 timestamp,
 
     shift = state & GDK_SHIFT_MASK;
     ctrl = state & GDK_CONTROL_MASK;
-    alt = state & GDK_MOD1_MASK;
+    alt = state & inst->meta_mod_mask;
 
     raw_mouse_mode =
         send_raw_mouse && !(shift && conf_get_int(inst->conf,
@@ -1366,11 +1858,11 @@ gboolean button_internal(struct gui_data *inst, guint32 timestamp,
 
     if (!raw_mouse_mode) {
         if (ebutton == 4 && type == GDK_BUTTON_PRESS) {
-            term_scroll(inst->term, 0, -5);
+            term_scroll(inst->term, 0, -SCROLL_INCREMENT_LINES);
             return TRUE;
         }
         if (ebutton == 5 && type == GDK_BUTTON_PRESS) {
-            term_scroll(inst->term, 0, +5);
+            term_scroll(inst->term, 0, +SCROLL_INCREMENT_LINES);
             return TRUE;
         }
     }
@@ -1430,8 +1922,15 @@ gboolean button_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
 gboolean scroll_event(GtkWidget *widget, GdkEventScroll *event, gpointer data)
 {
     struct gui_data *inst = (struct gui_data *)data;
-    guint button;
 
+#if GTK_CHECK_VERSION(3,4,0)
+    gdouble dx, dy;
+    if (gdk_event_get_scroll_deltas((GdkEvent *)event, &dx, &dy)) {
+        return scroll_internal(inst, dy, event->state, event->x, event->y);
+    } else
+        return FALSE;
+#else
+    guint button;
     if (event->direction == GDK_SCROLL_UP)
 	button = 4;
     else if (event->direction == GDK_SCROLL_DOWN)
@@ -1441,6 +1940,7 @@ gboolean scroll_event(GtkWidget *widget, GdkEventScroll *event, gpointer data)
 
     return button_internal(inst, event->time, GDK_BUTTON_PRESS,
 			   button, event->state, event->x, event->y);
+#endif
 }
 #endif
 
@@ -1456,7 +1956,7 @@ gint motion_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)
 
     shift = event->state & GDK_SHIFT_MASK;
     ctrl = event->state & GDK_CONTROL_MASK;
-    alt = event->state & GDK_MOD1_MASK;
+    alt = event->state & inst->meta_mod_mask;
     if (event->state & GDK_BUTTON1_MASK)
 	button = MBT_LEFT;
     else if (event->state & GDK_BUTTON2_MASK)
@@ -1869,7 +2369,12 @@ void set_gdk_window_background(GdkWindow *win, const GdkColor *col)
     rgba.alpha = 1.0;
     gdk_window_set_background_rgba(win, &rgba);
 #else
-    gdk_window_set_background(win, col);
+    {
+        /* For GTK1, which doesn't have a 'const' on
+         * gdk_window_set_background's second parameter type. */
+        GdkColor col_mutable = *col;
+        gdk_window_set_background(win, &col_mutable);
+    }
 #endif
 }
 
@@ -1969,35 +2474,164 @@ void palette_reset(void *frontend)
     }
 }
 
-/* Ensure that all the cut buffers exist - according to the ICCCM, we must
- * do this before we start using cut buffers.
+#ifdef JUST_USE_GTK_CLIPBOARD_UTF8
+
+/* ----------------------------------------------------------------------
+ * Clipboard handling, using the high-level GtkClipboard interface in
+ * as hands-off a way as possible. We write and read the clipboard as
+ * UTF-8 text, and let GTK deal with converting to any other text
+ * formats it feels like.
  */
-void init_cutbuffers()
+
+void init_clipboard(struct gui_data *inst)
 {
-#ifndef NOT_X_WINDOWS
-    unsigned char empty[] = "";
-    Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
-    XChangeProperty(disp, GDK_ROOT_WINDOW(),
-		    XA_CUT_BUFFER0, XA_STRING, 8, PropModeAppend, empty, 0);
-    XChangeProperty(disp, GDK_ROOT_WINDOW(),
-		    XA_CUT_BUFFER1, XA_STRING, 8, PropModeAppend, empty, 0);
-    XChangeProperty(disp, GDK_ROOT_WINDOW(),
-		    XA_CUT_BUFFER2, XA_STRING, 8, PropModeAppend, empty, 0);
-    XChangeProperty(disp, GDK_ROOT_WINDOW(),
-		    XA_CUT_BUFFER3, XA_STRING, 8, PropModeAppend, empty, 0);
-    XChangeProperty(disp, GDK_ROOT_WINDOW(),
-		    XA_CUT_BUFFER4, XA_STRING, 8, PropModeAppend, empty, 0);
-    XChangeProperty(disp, GDK_ROOT_WINDOW(),
-		    XA_CUT_BUFFER5, XA_STRING, 8, PropModeAppend, empty, 0);
-    XChangeProperty(disp, GDK_ROOT_WINDOW(),
-		    XA_CUT_BUFFER6, XA_STRING, 8, PropModeAppend, empty, 0);
-    XChangeProperty(disp, GDK_ROOT_WINDOW(),
-		    XA_CUT_BUFFER7, XA_STRING, 8, PropModeAppend, empty, 0);
-#endif
+    inst->clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(),
+                                                    DEFAULT_CLIPBOARD);
+}
+
+/*
+ * Because calling gtk_clipboard_set_with_data triggers a call to the
+ * clipboard_clear function from the last time, we need to arrange a
+ * way to distinguish a real call to clipboard_clear for the _new_
+ * instance of the clipboard data from the leftover call for the
+ * outgoing one. We do this by setting the user data field in our
+ * gtk_clipboard_set_with_data() call, instead of the obvious pointer
+ * to 'inst', to one of these.
+ */
+struct clipboard_data_instance {
+    struct gui_data *inst;
+    char *pasteout_data_utf8;
+    int pasteout_data_utf8_len;
+};
+
+static void clipboard_provide_data(GtkClipboard *clipboard,
+                                   GtkSelectionData *selection_data,
+                                   guint info, gpointer data)
+{
+    struct clipboard_data_instance *cdi =
+        (struct clipboard_data_instance *)data;
+    struct gui_data *inst = cdi->inst;
+
+    if (inst->current_cdi == cdi) {
+        gtk_selection_data_set_text(selection_data, cdi->pasteout_data_utf8,
+                                    cdi->pasteout_data_utf8_len);
+    }
+}
+
+static void clipboard_clear(GtkClipboard *clipboard, gpointer data)
+{
+    struct clipboard_data_instance *cdi =
+        (struct clipboard_data_instance *)data;
+    struct gui_data *inst = cdi->inst;
+
+    if (inst->current_cdi == cdi) {
+        term_deselect(inst->term);
+        inst->current_cdi = NULL;
+    }
+    sfree(cdi->pasteout_data_utf8);
+    sfree(cdi);
+}
+
+void write_clip(void *frontend, wchar_t *data, int *attr, int len,
+                int must_deselect)
+{
+    struct gui_data *inst = (struct gui_data *)frontend;
+    struct clipboard_data_instance *cdi;
+
+    if (inst->direct_to_font) {
+        /* In this clipboard mode, we just can't paste if we're in
+         * direct-to-font mode. Fortunately, that shouldn't be
+         * important, because we'll only use this clipboard handling
+         * code on systems where that kind of font doesn't exist
+         * anyway. */
+        return;
+    }
+
+    cdi = snew(struct clipboard_data_instance);
+    cdi->inst = inst;
+    inst->current_cdi = cdi;
+    cdi->pasteout_data_utf8 = snewn(len*6, char);
+    {
+        const wchar_t *tmp = data;
+        int tmplen = len;
+        cdi->pasteout_data_utf8_len =
+            charset_from_unicode(&tmp, &tmplen, cdi->pasteout_data_utf8,
+                                 len*6, CS_UTF8, NULL, NULL, 0);
+    }
+
+    /*
+     * It would be nice to just call gtk_clipboard_set_text() in place
+     * of all of the faffing below. Unfortunately, that won't give me
+     * access to the clipboard-clear event, which we use to visually
+     * deselect text in the terminal.
+     */
+    {
+        GtkTargetList *targetlist;
+        GtkTargetEntry *targettable;
+        gint n_targets;
+
+        targetlist = gtk_target_list_new(NULL, 0);
+        gtk_target_list_add_text_targets(targetlist, 0);
+        targettable = gtk_target_table_new_from_list(targetlist, &n_targets);
+        gtk_clipboard_set_with_data(inst->clipboard, targettable, n_targets,
+                                    clipboard_provide_data, clipboard_clear,
+                                    cdi);
+        gtk_target_table_free(targettable, n_targets);
+        gtk_target_list_unref(targetlist);
+    }
 }
 
+static void clipboard_text_received(GtkClipboard *clipboard,
+                                    const gchar *text, gpointer data)
+{
+    struct gui_data *inst = (struct gui_data *)data;
+    int length;
+
+    if (!text)
+        return;
+
+    length = strlen(text);
+
+    if (inst->pastein_data)
+	sfree(inst->pastein_data);
+
+    inst->pastein_data = snewn(length, wchar_t);
+    inst->pastein_data_len = mb_to_wc(CS_UTF8, 0, text, length,
+                                      inst->pastein_data, length);
+
+    term_do_paste(inst->term);
+}
+
+void request_paste(void *frontend)
+{
+    struct gui_data *inst = (struct gui_data *)frontend;
+    gtk_clipboard_request_text(inst->clipboard, clipboard_text_received, inst);
+}
+
+#else /* JUST_USE_GTK_CLIPBOARD_UTF8 */
+
+/* ----------------------------------------------------------------------
+ * Clipboard handling for X, using the low-level gtk_selection_*
+ * interface, handling conversions to fiddly things like compound text
+ * ourselves, and storing in X cut buffers too.
+ *
+ * This version of the clipboard code has to be kept around for GTK1,
+ * which doesn't have the higher-level GtkClipboard interface at all.
+ * And since it works on GTK2 and GTK3 too and has had a good few
+ * years of shakedown and bug fixing, we might as well keep using it
+ * where it's applicable.
+ *
+ * It's _possible_ that we might be able to replicate all the
+ * important wrinkles of this code in GtkClipboard. (In particular,
+ * cut buffers or local analogue look as if they might be accessible
+ * via gtk_clipboard_set_can_store(), and delivering text in
+ * non-Unicode formats only in the direct-to-font case ought to be
+ * possible if we can figure out the right set of things to put in the
+ * GtkTargetList.) But that work can wait until there's a need for it!
+ */
+
 /* Store the data in a cut-buffer. */
-void store_cutbuffer(char * ptr, int len)
+static void store_cutbuffer(char * ptr, int len)
 {
 #ifndef NOT_X_WINDOWS
     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
@@ -2010,7 +2644,7 @@ void store_cutbuffer(char * ptr, int len)
 /* Retrieve data from a cut-buffer.
  * Returned data needs to be freed with XFree().
  */
-char * retrieve_cutbuffer(int * nbytes)
+static char *retrieve_cutbuffer(int *nbytes)
 {
 #ifndef NOT_X_WINDOWS
     Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
@@ -2026,7 +2660,8 @@ char * retrieve_cutbuffer(int * nbytes)
 #endif
 }
 
-void write_clip(void *frontend, wchar_t * data, int *attr, int len, int must_deselect)
+void write_clip(void *frontend, wchar_t *data, int *attr, int len,
+                int must_deselect)
 {
     struct gui_data *inst = (struct gui_data *)frontend;
     if (inst->pasteout_data)
@@ -2124,8 +2759,8 @@ void write_clip(void *frontend, wchar_t * data, int *attr, int len, int must_des
 	term_deselect(inst->term);
 }
 
-void selection_get(GtkWidget *widget, GtkSelectionData *seldata,
-		   guint info, guint time_stamp, gpointer data)
+static void selection_get(GtkWidget *widget, GtkSelectionData *seldata,
+                          guint info, guint time_stamp, gpointer data)
 {
     struct gui_data *inst = (struct gui_data *)data;
     GdkAtom target = gtk_selection_data_get_target(seldata);
@@ -2143,8 +2778,8 @@ void selection_get(GtkWidget *widget, GtkSelectionData *seldata,
 			       inst->pasteout_data_len);
 }
 
-gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata,
-		     gpointer data)
+static gint selection_clear(GtkWidget *widget, GdkEventSelection *seldata,
+                            gpointer data)
 {
     struct gui_data *inst = (struct gui_data *)data;
 
@@ -2195,10 +2830,8 @@ void request_paste(void *frontend)
     }
 }
 
-gint idle_paste_func(gpointer data);   /* forward ref */
-
-void selection_received(GtkWidget *widget, GtkSelectionData *seldata,
-			guint time, gpointer data)
+static void selection_received(GtkWidget *widget, GtkSelectionData *seldata,
+                               guint time, gpointer data)
 {
     struct gui_data *inst = (struct gui_data *)data;
     char *text;
@@ -2319,6 +2952,48 @@ void selection_received(GtkWidget *widget, GtkSelectionData *seldata,
 #endif
 }
 
+void init_clipboard(struct gui_data *inst)
+{
+#ifndef NOT_X_WINDOWS
+    /*
+     * Ensure that all the cut buffers exist - according to the ICCCM,
+     * we must do this before we start using cut buffers.
+     */
+    unsigned char empty[] = "";
+    Display *disp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
+    XChangeProperty(disp, GDK_ROOT_WINDOW(),
+		    XA_CUT_BUFFER0, XA_STRING, 8, PropModeAppend, empty, 0);
+    XChangeProperty(disp, GDK_ROOT_WINDOW(),
+		    XA_CUT_BUFFER1, XA_STRING, 8, PropModeAppend, empty, 0);
+    XChangeProperty(disp, GDK_ROOT_WINDOW(),
+		    XA_CUT_BUFFER2, XA_STRING, 8, PropModeAppend, empty, 0);
+    XChangeProperty(disp, GDK_ROOT_WINDOW(),
+		    XA_CUT_BUFFER3, XA_STRING, 8, PropModeAppend, empty, 0);
+    XChangeProperty(disp, GDK_ROOT_WINDOW(),
+		    XA_CUT_BUFFER4, XA_STRING, 8, PropModeAppend, empty, 0);
+    XChangeProperty(disp, GDK_ROOT_WINDOW(),
+		    XA_CUT_BUFFER5, XA_STRING, 8, PropModeAppend, empty, 0);
+    XChangeProperty(disp, GDK_ROOT_WINDOW(),
+		    XA_CUT_BUFFER6, XA_STRING, 8, PropModeAppend, empty, 0);
+    XChangeProperty(disp, GDK_ROOT_WINDOW(),
+		    XA_CUT_BUFFER7, XA_STRING, 8, PropModeAppend, empty, 0);
+#endif
+
+    g_signal_connect(G_OBJECT(inst->area), "selection_received",
+                     G_CALLBACK(selection_received), inst);
+    g_signal_connect(G_OBJECT(inst->area), "selection_get",
+                     G_CALLBACK(selection_get), inst);
+    g_signal_connect(G_OBJECT(inst->area), "selection_clear_event",
+                     G_CALLBACK(selection_clear), inst);
+}
+
+/*
+ * End of selection/clipboard handling.
+ * ----------------------------------------------------------------------
+ */
+
+#endif /* JUST_USE_GTK_CLIPBOARD_UTF8 */
+
 void get_clip(void *frontend, wchar_t ** p, int *len)
 {
     struct gui_data *inst = (struct gui_data *)frontend;
@@ -2416,11 +3091,8 @@ void do_beep(void *frontend, int mode)
 int char_width(Context ctx, int uc)
 {
     /*
-     * Under X, any fixed-width font really _is_ fixed-width.
-     * Double-width characters will be dealt with using a separate
-     * font. For the moment we can simply return 1.
-     * 
-     * FIXME: but is that also true of Pango?
+     * In this front end, double-width characters are handled using a
+     * separate font, so this can safely just return 1 always.
      */
     return 1;
 }
@@ -2429,30 +3101,28 @@ Context get_ctx(void *frontend)
 {
     struct gui_data *inst = (struct gui_data *)frontend;
     struct draw_ctx *dctx;
-    GdkWindow *target;
 
     if (!gtk_widget_get_window(inst->area))
 	return NULL;
 
-#ifndef NO_BACKING_PIXMAPS
-    target = inst->pixmap;
-#else
-    target = gtk_widget_get_window(inst->area);
-#endif
-
     dctx = snew(struct draw_ctx);
     dctx->inst = inst;
     dctx->uctx.type = inst->drawtype;
 #ifdef DRAW_TEXT_GDK
     if (dctx->uctx.type == DRAWTYPE_GDK) {
-        dctx->uctx.u.gdk.target = target;
+        /* If we're doing GDK-based drawing, then we also expect
+         * inst->pixmap to exist. */
+        dctx->uctx.u.gdk.target = inst->pixmap;
         dctx->uctx.u.gdk.gc = gdk_gc_new(gtk_widget_get_window(inst->area));
     }
 #endif
 #ifdef DRAW_TEXT_CAIRO
     if (dctx->uctx.type == DRAWTYPE_CAIRO) {
         dctx->uctx.u.cairo.widget = GTK_WIDGET(inst->area);
-        dctx->uctx.u.cairo.cr = gdk_cairo_create(target);
+        /* If we're doing Cairo drawing, we expect inst->surface to
+         * exist, and we draw to that first, regardless of whether we
+         * subsequently copy the results to inst->pixmap. */
+        dctx->uctx.u.cairo.cr = cairo_create(inst->surface);
         cairo_setup_dctx(dctx);
     }
 #endif
@@ -2479,23 +3149,31 @@ void free_ctx(Context ctx)
 
 static void draw_update(struct draw_ctx *dctx, int x, int y, int w, int h)
 {
-#ifndef NO_BACKING_PIXMAPS
-#ifdef DRAW_TEXT_GDK
-    if (dctx->uctx.type == DRAWTYPE_GDK) {
-        gdk_draw_pixmap(gtk_widget_get_window(dctx->inst->area),
-                        dctx->uctx.u.gdk.gc, dctx->inst->pixmap,
-                        x, y, x, y, w, h);
-    }
-#endif
-#ifdef DRAW_TEXT_CAIRO /* FIXME: and not GTK3 where a cairo_t is all we have */
+#if defined DRAW_TEXT_CAIRO && !defined NO_BACKING_PIXMAPS
     if (dctx->uctx.type == DRAWTYPE_CAIRO) {
-        GdkGC *gc = gdk_gc_new(gtk_widget_get_window(dctx->inst->area));
-        gdk_draw_pixmap(gtk_widget_get_window(dctx->inst->area),
-                        gc, dctx->inst->pixmap, x, y, x, y, w, h);
-        gdk_gc_unref(gc);
+        /*
+         * If inst->surface and inst->pixmap both exist, then we've
+         * just drawn new content to the former which we must copy to
+         * the latter.
+         */
+        cairo_t *cr = gdk_cairo_create(dctx->inst->pixmap);
+        cairo_set_source_surface(cr, dctx->inst->surface, 0, 0);
+        cairo_rectangle(cr, x, y, w, h);
+        cairo_fill(cr);
+        cairo_destroy(cr);
     }
 #endif
-#endif
+
+    /*
+     * Now we just queue a window redraw, which will cause
+     * inst->surface or inst->pixmap (whichever is appropriate for our
+     * compile mode) to be copied to the real window when we receive
+     * the resulting "expose" or "draw" event.
+     *
+     * Amazingly, this one API call is actually valid in all versions
+     * of GTK :-)
+     */
+    gtk_widget_queue_draw_area(dctx->inst->area, x, y, w, h);
 }
 
 static void draw_set_colour(struct draw_ctx *dctx, int col)
@@ -2693,10 +3371,11 @@ static void draw_stretch_after(struct draw_ctx *dctx, int x, int y,
 static void draw_backing_rect(struct gui_data *inst)
 {
     struct draw_ctx *dctx = get_ctx(inst);
+    int w = inst->width * inst->font_width + 2*inst->window_border;
+    int h = inst->height * inst->font_height + 2*inst->window_border;
     draw_set_colour(dctx, 258);
-    draw_rectangle(dctx, 1, 0, 0,
-                   inst->width * inst->font_width + 2*inst->window_border,
-                   inst->height * inst->font_height + 2*inst->window_border);
+    draw_rectangle(dctx, 1, 0, 0, w, h);
+    draw_update(dctx, 0, 0, w, h);
     free_ctx(dctx);
 }
 
@@ -2711,7 +3390,7 @@ void do_text_internal(Context ctx, int x, int y, wchar_t *text, int len,
 {
     struct draw_ctx *dctx = (struct draw_ctx *)ctx;
     struct gui_data *inst = dctx->inst;
-    int ncombining, combining;
+    int ncombining;
     int nfg, nbg, t, fontid, shadow, rlen, widefactor, bold;
     int monochrome =
         gdk_visual_get_depth(gtk_widget_get_visual(inst->area)) == 1;
@@ -2808,11 +3487,20 @@ void do_text_internal(Context ctx, int x, int y, wchar_t *text, int len,
                    rlen*widefactor*inst->font_width, inst->font_height);
 
     draw_set_colour(dctx, nfg);
-    for (combining = 0; combining < ncombining; combining++) {
+    if (ncombining > 1) {
+        assert(len == 1);
+        unifont_draw_combining(&dctx->uctx, inst->fonts[fontid],
+                               x*inst->font_width+inst->window_border,
+                               (y*inst->font_height+inst->window_border+
+                                inst->fonts[0]->ascent),
+                               text, ncombining, widefactor > 1,
+                               bold, inst->font_width);
+    } else {
         unifont_draw_text(&dctx->uctx, inst->fonts[fontid],
                           x*inst->font_width+inst->window_border,
-                          y*inst->font_height+inst->window_border+inst->fonts[0]->ascent,
-                          text + combining, len, widefactor > 1,
+                          (y*inst->font_height+inst->window_border+
+                           inst->fonts[0]->ascent),
+                          text, len, widefactor > 1,
                           bold, inst->font_width);
     }
 
@@ -3061,7 +3749,7 @@ static void help(FILE *fp) {
 "  -ut, +ut                  Do(default) or do not update utmp\n"
 "  -ls, +ls                  Do(default) or do not make shell a login shell\n"
 "  -sb, +sb                  Do(default) or do not display a scrollbar\n"
-"  -log PATH                 Log all output to a file\n"
+"  -log PATH, -sessionlog PATH  Log all output to a file\n"
 "  -nethack                  Map numeric keypad to hjklyubn direction keys\n"
 "  -xrm RESOURCE-STRING      Set an X resource\n"
 "  -e COMMAND [ARGS...]      Execute command (consumes all remaining args)\n"
@@ -3201,27 +3889,47 @@ int do_cmdline(int argc, char **argv, int do_everything, int *allow_launch,
 	} else if (!strcmp(p, "-fg") || !strcmp(p, "-bg") ||
 		   !strcmp(p, "-bfg") || !strcmp(p, "-bbg") ||
 		   !strcmp(p, "-cfg") || !strcmp(p, "-cbg")) {
-	    GdkColor col;
-
 	    EXPECTS_ARG;
 	    SECOND_PASS_ONLY;
-	    if (!gdk_color_parse(val, &col)) {
-		err = 1;
-		fprintf(stderr, "%s: unable to parse colour \"%s\"\n",
-                        appname, val);
-	    } else {
-		int index;
-		index = (!strcmp(p, "-fg") ? 0 :
-			 !strcmp(p, "-bg") ? 2 :
-			 !strcmp(p, "-bfg") ? 1 :
-			 !strcmp(p, "-bbg") ? 3 :
-			 !strcmp(p, "-cfg") ? 4 :
-			 !strcmp(p, "-cbg") ? 5 : -1);
-		assert(index != -1);
-		conf_set_int_int(conf, CONF_colours, index*3+0, col.red / 256);
-		conf_set_int_int(conf, CONF_colours, index*3+1,col.green/ 256);
-		conf_set_int_int(conf, CONF_colours, index*3+2, col.blue/ 256);
-	    }
+
+            {
+#if GTK_CHECK_VERSION(3,0,0)
+                GdkRGBA rgba;
+                int success = gdk_rgba_parse(&rgba, val);
+#else
+                GdkColor col;
+                int success = gdk_color_parse(val, &col);
+#endif
+
+                if (!success) {
+                    err = 1;
+                    fprintf(stderr, "%s: unable to parse colour \"%s\"\n",
+                            appname, val);
+                } else {
+#if GTK_CHECK_VERSION(3,0,0)
+                    int r = rgba.red * 255;
+                    int g = rgba.green * 255;
+                    int b = rgba.blue * 255;
+#else
+                    int r = col.red / 256;
+                    int g = col.green / 256;
+                    int b = col.blue / 256;
+#endif
+
+                    int index;
+                    index = (!strcmp(p, "-fg") ? 0 :
+                             !strcmp(p, "-bg") ? 2 :
+                             !strcmp(p, "-bfg") ? 1 :
+                             !strcmp(p, "-bbg") ? 3 :
+                             !strcmp(p, "-cfg") ? 4 :
+                             !strcmp(p, "-cbg") ? 5 : -1);
+                    assert(index != -1);
+
+                    conf_set_int_int(conf, CONF_colours, index*3+0, r);
+                    conf_set_int_int(conf, CONF_colours, index*3+1, g);
+                    conf_set_int_int(conf, CONF_colours, index*3+2, b);
+                }
+            }
 
 	} else if (use_pty_argv && !strcmp(p, "-e")) {
 	    /* This option swallows all further arguments. */
@@ -3358,6 +4066,12 @@ void uxsel_input_remove(uxsel_id *id) {
     sfree(id);
 }
 
+int frontend_is_utf8(void *frontend)
+{
+    struct gui_data *inst = (struct gui_data *)frontend;
+    return inst->ucsdata.line_codepage == CS_UTF8;
+}
+
 char *setup_fonts_ucs(struct gui_data *inst)
 {
     int shadowbold = conf_get_int(inst->conf, CONF_shadowbold);
@@ -4108,6 +4822,9 @@ int pt_main(int argc, char **argv)
     inst->quit_fn_scheduled = FALSE;
     inst->idle_fn_scheduled = FALSE;
     inst->drawtype = DRAWTYPE_DEFAULT;
+#if GTK_CHECK_VERSION(3,4,0)
+    inst->cumulative_scroll = 0.0;
+#endif
 
     /* defer any child exit handling until we're ready to deal with
      * it */
@@ -4171,8 +4888,6 @@ int pt_main(int argc, char **argv)
             exit(1);
         }
     }
-    init_cutbuffers();
-
     inst->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
     {
         const char *winclass = conf_get_str(inst->conf, CONF_winclass);
@@ -4190,6 +4905,14 @@ int pt_main(int argc, char **argv)
     inst->height = conf_get_int(inst->conf, CONF_height);
     cache_conf_values(inst);
 
+    init_clipboard(inst);
+
+    set_geom_hints(inst);
+
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_window_set_default_geometry(GTK_WINDOW(inst->window),
+                                    inst->width, inst->height);
+#else
     {
         int w = inst->font_width * inst->width + 2*inst->window_border;
         int h = inst->font_height * inst->height + 2*inst->window_border;
@@ -4199,6 +4922,8 @@ int pt_main(int argc, char **argv)
         gtk_drawing_area_size(GTK_DRAWING_AREA(inst->area), w, h);
 #endif
     }
+#endif
+
     inst->sbar_adjust = GTK_ADJUSTMENT(gtk_adjustment_new(0,0,0,0,0,0));
     inst->sbar = gtk_vscrollbar_new(inst->sbar_adjust);
     inst->hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
@@ -4215,8 +4940,6 @@ int pt_main(int argc, char **argv)
 
     gtk_container_add(GTK_CONTAINER(inst->window), GTK_WIDGET(inst->hbox));
 
-    set_geom_hints(inst);
-
     gtk_widget_show(inst->area);
     if (conf_get_int(inst->conf, CONF_scrollbar))
 	gtk_widget_show(inst->sbar);
@@ -4271,12 +4994,6 @@ int pt_main(int argc, char **argv)
 #endif
     g_signal_connect(G_OBJECT(inst->area), "motion_notify_event",
                      G_CALLBACK(motion_event), inst);
-    g_signal_connect(G_OBJECT(inst->area), "selection_received",
-                     G_CALLBACK(selection_received), inst);
-    g_signal_connect(G_OBJECT(inst->area), "selection_get",
-                     G_CALLBACK(selection_get), inst);
-    g_signal_connect(G_OBJECT(inst->area), "selection_clear_event",
-                     G_CALLBACK(selection_clear), inst);
 #if GTK_CHECK_VERSION(2,0,0)
     g_signal_connect(G_OBJECT(inst->imc), "commit",
                      G_CALLBACK(input_method_commit_event), inst);
@@ -4287,7 +5004,11 @@ int pt_main(int argc, char **argv)
     gtk_widget_add_events(GTK_WIDGET(inst->area),
 			  GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK |
 			  GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
-			  GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK);
+			  GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK
+#if GTK_CHECK_VERSION(3,4,0)
+                          | GDK_SMOOTH_SCROLL_MASK
+#endif
+        );
 
     {
 	extern const char *const *const main_icon[];