gtkutil.c

/* Functions for creating and updating GTK widgets.

Copyright (C) 2003-2018 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */

#include <config.h>

#ifdef USE_GTK
#include <float.h>
#include <stdio.h>

#include <c-ctype.h>

#include "lisp.h"
#include "dispextern.h"
#include "frame.h"
#include "systime.h"
#include "xterm.h"
#include "blockinput.h"
#include "window.h"
#include "gtkutil.h"
#include "termhooks.h"
#include "keyboard.h"
#include "coding.h"

#include <gdk/gdkkeysyms.h>

#ifdef HAVE_XFT
#include <X11/Xft/Xft.h>
#endif

#ifdef HAVE_GTK3
#include <gtk/gtkx.h>
#include "emacsgtkfixed.h"
#endif

#ifdef HAVE_XDBE
#include <X11/extensions/Xdbe.h>
#endif

#ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
#define gtk_widget_set_has_window(w, b) \
  (gtk_fixed_set_has_window (GTK_FIXED (w), b))
#endif
#ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
#define gtk_dialog_get_action_area(w) ((w)->action_area)
#define gtk_dialog_get_content_area(w) ((w)->vbox)
#endif
#ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
#define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
#endif
#ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
#define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
#define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
#define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
#define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
#endif
#if GTK_CHECK_VERSION (2, 12, 0)
#define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
#else
#define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
#endif

#if ! GTK_CHECK_VERSION (2, 14, 0)
#define gtk_adjustment_configure(adj, xvalue, xlower,            \
                                 xupper, xstep_increment,        \
                                 xpage_increment, xpagesize)     \
  do {                                                           \
    adj->lower = xlower;                                         \
    adj->upper = xupper;                                         \
    adj->page_size = xpagesize;                                  \
    gtk_adjustment_set_value (adj, xvalue);                      \
    adj->page_increment = xpage_increment;                       \
    adj->step_increment = xstep_increment;                       \
  } while (0)
#endif /* < Gtk+ 2.14 */

#ifdef HAVE_FREETYPE
#if GTK_CHECK_VERSION (3, 2, 0)
#define USE_NEW_GTK_FONT_CHOOSER 1
#else
#define USE_NEW_GTK_FONT_CHOOSER 0
#define gtk_font_chooser_dialog_new(x, y) \
  gtk_font_selection_dialog_new (x)
#undef GTK_FONT_CHOOSER
#define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
#define  gtk_font_chooser_set_font(x, y) \
  gtk_font_selection_dialog_set_font_name (x, y)
#endif
#endif /* HAVE_FREETYPE */

#if GTK_CHECK_VERSION (3, 10, 0)
#define XG_TEXT_CANCEL "Cancel"
#define XG_TEXT_OK     "OK"
#define XG_TEXT_OPEN   "Open"
#else
#define XG_TEXT_CANCEL GTK_STOCK_CANCEL
#define XG_TEXT_OK     GTK_STOCK_OK
#define XG_TEXT_OPEN   GTK_STOCK_OPEN
#endif

#ifndef HAVE_GTK3
#ifdef USE_GTK_TOOLTIP
#define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
#endif
#define gdk_window_get_geometry(w, a, b, c, d) \
  gdk_window_get_geometry (w, a, b, c, d, 0)
#define gdk_x11_window_lookup_for_display(d, w) \
  gdk_xid_table_lookup_for_display (d, w)
#define gtk_box_new(ori, spacing)                                       \
  ((ori) == GTK_ORIENTATION_HORIZONTAL                                  \
   ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
#define gtk_scrollbar_new(ori, spacing)                                 \
  ((ori) == GTK_ORIENTATION_HORIZONTAL                                  \
   ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
#ifndef GDK_KEY_g
#define GDK_KEY_g GDK_g
#endif
#endif /* HAVE_GTK3 */

#define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))

static void update_theme_scrollbar_width (void);
static void update_theme_scrollbar_height (void);

#define TB_INFO_KEY "xg_frame_tb_info"
struct xg_frame_tb_info
{
  Lisp_Object last_tool_bar;
  Lisp_Object style;
  int n_last_items;
  int hmargin, vmargin;
  GtkTextDirection dir;
};

static GtkWidget * xg_get_widget_from_map (ptrdiff_t idx);


/***********************************************************************
                      Display handling functions
 ***********************************************************************/

/* Keep track of the default display, or NULL if there is none.  Emacs
   may close all its displays.  */

static GdkDisplay *gdpy_def;

/* When the GTK widget W is to be created on a display for F that
   is not the default display, set the display for W.
   W can be a GtkMenu or a GtkWindow widget.  */

static void
xg_set_screen (GtkWidget *w, struct frame *f)
{
  if (FRAME_X_DISPLAY (f) != DEFAULT_GDK_DISPLAY ())
    {
      GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
      GdkScreen *gscreen = gdk_display_get_default_screen (gdpy);

      if (GTK_IS_MENU (w))
        gtk_menu_set_screen (GTK_MENU (w), gscreen);
      else
        gtk_window_set_screen (GTK_WINDOW (w), gscreen);
    }
}


/* Open a display named by DISPLAY_NAME.  The display is returned in *DPY.
   *DPY is set to NULL if the display can't be opened.

   Returns non-zero if display could be opened, zero if display could not
   be opened, and less than zero if the GTK version doesn't support
   multiple displays.  */

void
xg_display_open (char *display_name, Display **dpy)
{
  GdkDisplay *gdpy;

  unrequest_sigio ();  /* See comment in x_display_ok, xterm.c.  */
  gdpy = gdk_display_open (display_name);
  request_sigio ();
  if (!gdpy_def && gdpy)
    {
      gdpy_def = gdpy;
      gdk_display_manager_set_default_display (gdk_display_manager_get (),
					       gdpy);
    }

  *dpy = gdpy ? GDK_DISPLAY_XDISPLAY (gdpy) : NULL;
}

/* Scaling/HiDPI functions. */
static int
xg_get_gdk_scale (void)
{
  const char *sscale = getenv ("GDK_SCALE");

  if (sscale)
    {
      long scale = atol (sscale);
      if (0 < scale)
	return min (scale, INT_MAX);
    }

  return 1;
}

int
xg_get_scale (struct frame *f)
{
#if GTK_CHECK_VERSION (3, 10, 0)
  if (FRAME_GTK_WIDGET (f))
    return gtk_widget_get_scale_factor (FRAME_GTK_WIDGET (f));
#endif
  return xg_get_gdk_scale ();
}

/* Close display DPY.  */

void
xg_display_close (Display *dpy)
{
  GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (dpy);

  /* If this is the default display, try to change it before closing.
     If there is no other display to use, gdpy_def is set to NULL, and
     the next call to xg_display_open resets the default display.  */
  if (gdk_display_get_default () == gdpy)
    {
      struct x_display_info *dpyinfo;
      GdkDisplay *gdpy_new = NULL;

      /* Find another display.  */
      for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
        if (dpyinfo->display != dpy)
          {
	    gdpy_new = gdk_x11_lookup_xdisplay (dpyinfo->display);
	    gdk_display_manager_set_default_display (gdk_display_manager_get (),
						     gdpy_new);
            break;
          }
      gdpy_def = gdpy_new;
    }

#if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
  /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
     https://gitlab.gnome.org/GNOME/gtk/issues/221).  This way we
     can continue running, but there will be memory leaks.  */
  g_object_run_dispose (G_OBJECT (gdpy));
#else
  /* This seems to be fixed in GTK 2.10. */
  gdk_display_close (gdpy);
#endif
}


/***********************************************************************
                      Utility functions
 ***********************************************************************/

/* Create and return the cursor to be used for popup menus and
   scroll bars on display DPY.  */

GdkCursor *
xg_create_default_cursor (Display *dpy)
{
  GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (dpy);
  return gdk_cursor_new_for_display (gdpy, GDK_LEFT_PTR);
}

/* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel.  */

static GdkPixbuf *
xg_get_pixbuf_from_pix_and_mask (struct frame *f,
                                 Pixmap pix,
                                 Pixmap mask)
{
  GdkPixbuf *icon_buf = 0;
  int iunused;
  Window wunused;
  unsigned int width, height, depth, uunused;

  if (FRAME_DISPLAY_INFO (f)->red_bits != 8)
    return 0;
  XGetGeometry (FRAME_X_DISPLAY (f), pix, &wunused, &iunused, &iunused,
                &width, &height, &uunused, &depth);
  if (depth != 24)
    return 0;
  XImage *xim = XGetImage (FRAME_X_DISPLAY (f), pix, 0, 0, width, height,
			   ~0, XYPixmap);
  if (xim)
    {
      XImage *xmm = (! mask ? 0
		     : XGetImage (FRAME_X_DISPLAY (f), mask, 0, 0,
				  width, height, ~0, XYPixmap));
      icon_buf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, width, height);
      if (icon_buf)
	{
	  guchar *pixels = gdk_pixbuf_get_pixels (icon_buf);
	  int rowjunkwidth = gdk_pixbuf_get_rowstride (icon_buf) - width * 4;
	  for (int y = 0; y < height; y++, pixels += rowjunkwidth)
	    for (int x = 0; x < width; x++)
	      {
		unsigned long rgb = XGetPixel (xim, x, y);
		*pixels++ = (rgb >> 16) & 255;
		*pixels++ = (rgb >> 8) & 255;
		*pixels++ = rgb & 255;
		*pixels++ = xmm && !XGetPixel (xmm, x, y) ? 0 : 255;
	      }
	}

      if (xmm)
	XDestroyImage (xmm);
      XDestroyImage (xim);
    }

  return icon_buf;
}

static Lisp_Object
file_for_image (Lisp_Object image)
{
  Lisp_Object specified_file = Qnil;
  Lisp_Object tail;

  for (tail = XCDR (image);
       NILP (specified_file) && CONSP (tail) && CONSP (XCDR (tail));
       tail = XCDR (XCDR (tail)))
    if (EQ (XCAR (tail), QCfile))
      specified_file = XCAR (XCDR (tail));

  return specified_file;
}

/* For the image defined in IMG, make and return a GtkImage.  For displays with
   8 planes or less we must make a GdkPixbuf and apply the mask manually.
   Otherwise the highlighting and dimming the tool bar code in GTK does
   will look bad.  For display with more than 8 planes we just use the
   pixmap and mask directly.  For monochrome displays, GTK doesn't seem
   able to use external pixmaps, it looks bad whatever we do.
   The image is defined on the display where frame F is.
   WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
   If OLD_WIDGET is NULL, a new widget is constructed and returned.
   If OLD_WIDGET is not NULL, that widget is modified.  */

static GtkWidget *
xg_get_image_for_pixmap (struct frame *f,
                         struct image *img,
                         GtkWidget *widget,
                         GtkImage *old_widget)
{
  GdkPixbuf *icon_buf;

  /* If we have a file, let GTK do all the image handling.
     This seems to be the only way to make insensitive and activated icons
     look good in all cases.  */
  Lisp_Object specified_file = file_for_image (img->spec);
  Lisp_Object file;

  /* We already loaded the image once before calling this
     function, so this only fails if the image file has been removed.
     In that case, use the pixmap already loaded.  */

  if (STRINGP (specified_file)
      && STRINGP (file = x_find_image_file (specified_file)))
    {
      char *encoded_file = SSDATA (ENCODE_FILE (file));
      if (! old_widget)
        old_widget = GTK_IMAGE (gtk_image_new_from_file (encoded_file));
      else
        gtk_image_set_from_file (old_widget, encoded_file);

      return GTK_WIDGET (old_widget);
    }

  /* No file, do the image handling ourselves.  This will look very bad
     on a monochrome display, and sometimes bad on all displays with
     certain themes.  */

  /* This is a workaround to make icons look good on pseudo color
     displays.  Apparently GTK expects the images to have an alpha
     channel.  If they don't, insensitive and activated icons will
     look bad.  This workaround does not work on monochrome displays,
     and is strictly not needed on true color/static color displays (i.e.
     16 bits and higher).  But we do it anyway so we get a pixbuf that is
     not associated with the img->pixmap.  The img->pixmap may be removed
     by clearing the image cache and then the tool bar redraw fails, since
     Gtk+ assumes the pixmap is always there.  */
  icon_buf = xg_get_pixbuf_from_pix_and_mask (f, img->pixmap, img->mask);

  if (icon_buf)
    {
      if (! old_widget)
        old_widget = GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf));
      else
        gtk_image_set_from_pixbuf (old_widget, icon_buf);

      g_object_unref (G_OBJECT (icon_buf));
    }

  return GTK_WIDGET (old_widget);
}


/* Set CURSOR on W and all widgets W contain.  We must do like this
   for scroll bars and menu because they create widgets internally,
   and it is those widgets that are visible.  */

static void
xg_set_cursor (GtkWidget *w, GdkCursor *cursor)
{
  GdkWindow *window = gtk_widget_get_window (w);
  GList *children = gdk_window_peek_children (window);

  gdk_window_set_cursor (window, cursor);

  /* The scroll bar widget has more than one GDK window (had to look at
     the source to figure this out), and there is no way to set cursor
     on widgets in GTK.  So we must set the cursor for all GDK windows.
     Ditto for menus.  */

  for ( ; children; children = g_list_next (children))
    gdk_window_set_cursor (GDK_WINDOW (children->data), cursor);
}

/* Insert NODE into linked LIST.  */

static void
xg_list_insert (xg_list_node *list, xg_list_node *node)
{
  xg_list_node *list_start = list->next;

  if (list_start) list_start->prev = node;
  node->next = list_start;
  node->prev = 0;
  list->next = node;
}

/* Remove NODE from linked LIST.  */

static void
xg_list_remove (xg_list_node *list, xg_list_node *node)
{
  xg_list_node *list_start = list->next;
  if (node == list_start)
    {
      list->next = node->next;
      if (list->next) list->next->prev = 0;
    }
  else
    {
      node->prev->next = node->next;
      if (node->next) node->next->prev = node->prev;
    }
}

/* Allocate and return a utf8 version of STR.  If STR is already
   utf8 or NULL, just return a copy of STR.
   A new string is allocated and the caller must free the result
   with g_free.  */

static char *
get_utf8_string (const char *str)
{
  char *utf8_str;

  if (!str) return NULL;

  /* If not UTF-8, try current locale.  */
  if (!g_utf8_validate (str, -1, NULL))
    utf8_str = g_locale_to_utf8 (str, -1, 0, 0, 0);
  else
    return g_strdup (str);

  if (!utf8_str)
    {
      /* Probably some control characters in str.  Escape them. */
      ptrdiff_t len;
      ptrdiff_t nr_bad = 0;
      gsize bytes_read;
      gsize bytes_written;
      unsigned char *p = (unsigned char *)str;
      char *cp, *up;
      GError *err = NULL;

      while (! (cp = g_locale_to_utf8 ((char *)p, -1, &bytes_read,
                                       &bytes_written, &err))
             && err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
        {
          ++nr_bad;
          p += bytes_written+1;
          g_error_free (err);
          err = NULL;
        }

      if (err)
        {
          g_error_free (err);
          err = NULL;
        }
      if (cp) g_free (cp);

      len = strlen (str);
      ptrdiff_t alloc;
      if (INT_MULTIPLY_WRAPV (nr_bad, 4, &alloc)
	  || INT_ADD_WRAPV (len + 1, alloc, &alloc)
	  || SIZE_MAX < alloc)
	memory_full (SIZE_MAX);
      up = utf8_str = xmalloc (alloc);
      p = (unsigned char *)str;

      while (! (cp = g_locale_to_utf8 ((char *)p, -1, &bytes_read,
                                       &bytes_written, &err))
             && err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
        {
          memcpy (up, p, bytes_written);
          up += bytes_written;
          up += sprintf (up, "\\%03o", p[bytes_written]);
          p += bytes_written + 1;
          g_error_free (err);
          err = NULL;
        }

      if (cp)
        {
          strcpy (up, cp);
          g_free (cp);
        }
      if (err)
        {
          g_error_free (err);
          err = NULL;
        }
    }
  return utf8_str;
}

/* Check for special colors used in face spec for region face.
   The colors are fetched from the Gtk+ theme.
   Return true if color was found, false if not.  */

bool
xg_check_special_colors (struct frame *f,
                         const char *color_name,
                         XColor *color)
{
  bool success_p = 0;
  bool get_bg = strcmp ("gtk_selection_bg_color", color_name) == 0;
  bool get_fg = !get_bg && strcmp ("gtk_selection_fg_color", color_name) == 0;

  if (! FRAME_GTK_WIDGET (f) || ! (get_bg || get_fg))
    return success_p;

  block_input ();
  {
#ifdef HAVE_GTK3
    GtkStyleContext *gsty
      = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f));
    GdkRGBA col;
    char buf[sizeof "rgb://rrrr/gggg/bbbb"];
    int state = GTK_STATE_FLAG_SELECTED|GTK_STATE_FLAG_FOCUSED;
    if (get_fg)
      gtk_style_context_get_color (gsty, state, &col);
    else
      {
        GdkRGBA *c;
        /* FIXME: Retrieving the background color is deprecated in
           GTK+ 3.16.  New versions of GTK+ don't use the concept of a
           single background color any more, so we shouldn't query for
           it.  */
        gtk_style_context_get (gsty, state,
                               GTK_STYLE_PROPERTY_BACKGROUND_COLOR, &c,
                               NULL);
        col = *c;
        gdk_rgba_free (c);
      }

    unsigned short
      r = col.red * 65535,
      g = col.green * 65535,
      b = col.blue * 65535;
    sprintf (buf, "rgb:%04x/%04x/%04x", r, g, b);
    success_p = x_parse_color (f, buf, color) != 0;
#else
    GtkStyle *gsty = gtk_widget_get_style (FRAME_GTK_WIDGET (f));
    GdkColor *grgb = get_bg
      ? &gsty->bg[GTK_STATE_SELECTED]
      : &gsty->fg[GTK_STATE_SELECTED];

    color->red = grgb->red;
    color->green = grgb->green;
    color->blue = grgb->blue;
    color->pixel = grgb->pixel;
    success_p = 1;
#endif

  }
  unblock_input ();
  return success_p;
}



/***********************************************************************
                              Tooltips
 ***********************************************************************/
/* Gtk+ calls this callback when the parent of our tooltip dummy changes.
   We use that to pop down the tooltip.  This happens if Gtk+ for some
   reason wants to change or hide the tooltip.  */

#ifdef USE_GTK_TOOLTIP

static void
hierarchy_ch_cb (GtkWidget *widget,
                 GtkWidget *previous_toplevel,
                 gpointer   user_data)
{
  struct frame *f = user_data;
  struct x_output *x = f->output_data.x;
  GtkWidget *top = gtk_widget_get_toplevel (x->ttip_lbl);

  if (! top || ! GTK_IS_WINDOW (top))
      gtk_widget_hide (previous_toplevel);
}

/* Callback called when Gtk+ thinks a tooltip should be displayed.
   We use it to get the tooltip window and the tooltip widget so
   we can manipulate the ourselves.

   Return FALSE ensures that the tooltip is not shown.  */

static gboolean
qttip_cb (GtkWidget  *widget,
          gint        xpos,
          gint        ypos,
          gboolean    keyboard_mode,
          GtkTooltip *tooltip,
          gpointer    user_data)
{
  struct frame *f = user_data;
  struct x_output *x = f->output_data.x;
  if (x->ttip_widget == NULL)
    {
      GtkWidget *p;
      GList *list, *iter;

      g_object_set (G_OBJECT (widget), "has-tooltip", FALSE, NULL);
      x->ttip_widget = tooltip;
      g_object_ref (G_OBJECT (tooltip));
      x->ttip_lbl = gtk_label_new ("");
      g_object_ref (G_OBJECT (x->ttip_lbl));
      gtk_tooltip_set_custom (tooltip, x->ttip_lbl);
      x->ttip_window = GTK_WINDOW (gtk_widget_get_toplevel (x->ttip_lbl));

      /* Change stupid Gtk+ default line wrapping.  */
      p = gtk_widget_get_parent (x->ttip_lbl);
      list = gtk_container_get_children (GTK_CONTAINER (p));
      for (iter = list; iter; iter = g_list_next (iter))
        {
          GtkWidget *w = GTK_WIDGET (iter->data);
          if (GTK_IS_LABEL (w))
            gtk_label_set_line_wrap (GTK_LABEL (w), FALSE);
        }
      g_list_free (list);

      /* ATK needs an empty title for some reason.  */
      gtk_window_set_title (x->ttip_window, "");
      /* Realize so we can safely get screen later on.  */
      gtk_widget_realize (GTK_WIDGET (x->ttip_window));
      gtk_widget_realize (x->ttip_lbl);

      g_signal_connect (x->ttip_lbl, "hierarchy-changed",
                        G_CALLBACK (hierarchy_ch_cb), f);
    }
  return FALSE;
}

#endif /* USE_GTK_TOOLTIP */

/* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
   Return true if a system tooltip is available.  */

bool
xg_prepare_tooltip (struct frame *f,
                    Lisp_Object string,
                    int *width,
                    int *height)
{
#ifndef USE_GTK_TOOLTIP
  return 0;
#else
  struct x_output *x = f->output_data.x;
  GtkWidget *widget;
  GdkWindow *gwin;
  GdkScreen *screen;
  GtkSettings *settings;
  gboolean tt_enabled = TRUE;
  GtkRequisition req;
  Lisp_Object encoded_string;

  if (!x->ttip_lbl) return 0;

  block_input ();
  encoded_string = ENCODE_UTF_8 (string);
  widget = GTK_WIDGET (x->ttip_lbl);
  gwin = gtk_widget_get_window (GTK_WIDGET (x->ttip_window));
  screen = gdk_window_get_screen (gwin);
  settings = gtk_settings_get_for_screen (screen);
  g_object_get (settings, "gtk-enable-tooltips", &tt_enabled, NULL);
  if (tt_enabled)
    {
      g_object_set (settings, "gtk-enable-tooltips", FALSE, NULL);
      /* Record that we disabled it so it can be enabled again.  */
      g_object_set_data (G_OBJECT (x->ttip_window), "restore-tt",
                         (gpointer)f);
    }

  /* Prevent Gtk+ from hiding tooltip on mouse move and such.  */
  g_object_set_data (G_OBJECT
                     (gtk_widget_get_display (GTK_WIDGET (x->ttip_window))),
                     "gdk-display-current-tooltip", NULL);

  /* Put our dummy widget in so we can get callbacks for unrealize and
     hierarchy-changed.  */
  gtk_tooltip_set_custom (x->ttip_widget, widget);
  gtk_tooltip_set_text (x->ttip_widget, SSDATA (encoded_string));
  gtk_widget_get_preferred_size (GTK_WIDGET (x->ttip_window), NULL, &req);
  if (width) *width = req.width;
  if (height) *height = req.height;

  unblock_input ();

  return 1;
#endif /* USE_GTK_TOOLTIP */
}

/* Show the tooltip at ROOT_X and ROOT_Y.
   xg_prepare_tooltip must have been called before this function.  */

void
xg_show_tooltip (struct frame *f, int root_x, int root_y)
{
#ifdef USE_GTK_TOOLTIP
  struct x_output *x = f->output_data.x;
  if (x->ttip_window)
    {
      block_input ();
      gtk_window_move (x->ttip_window, root_x / xg_get_scale (f),
		       root_y / xg_get_scale (f));
      gtk_widget_show_all (GTK_WIDGET (x->ttip_window));
      unblock_input ();
    }
#endif
}

/* Hide tooltip if shown.  Do nothing if not shown.
   Return true if tip was hidden, false if not (i.e. not using
   system tooltips).  */

bool
xg_hide_tooltip (struct frame *f)
{
  bool ret = 0;
#ifdef USE_GTK_TOOLTIP
  if (f->output_data.x->ttip_window)
    {
      GtkWindow *win = f->output_data.x->ttip_window;
      block_input ();
      gtk_widget_hide (GTK_WIDGET (win));

      if (g_object_get_data (G_OBJECT (win), "restore-tt"))
        {
          GdkWindow *gwin = gtk_widget_get_window (GTK_WIDGET (win));
          GdkScreen *screen = gdk_window_get_screen (gwin);
          GtkSettings *settings = gtk_settings_get_for_screen (screen);
          g_object_set (settings, "gtk-enable-tooltips", TRUE, NULL);
        }
      unblock_input ();

      ret = 1;
    }
#endif
  return ret;
}


/***********************************************************************
    General functions for creating widgets, resizing, events, e.t.c.
 ***********************************************************************/

#if ! GTK_CHECK_VERSION (3, 22, 0)
static void
my_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
		const gchar *msg, gpointer user_data)
{
  if (!strstr (msg, "visible children"))
    fprintf (stderr, "XX %s-WARNING **: %s\n", log_domain, msg);
}
#endif

/* Make a geometry string and pass that to GTK.  It seems this is the
   only way to get geometry position right if the user explicitly
   asked for a position when starting Emacs.
   F is the frame we shall set geometry for.  */

static void
xg_set_geometry (struct frame *f)
{
  if (f->size_hint_flags & (USPosition | PPosition))
    {
      int scale = xg_get_scale (f);
#if ! GTK_CHECK_VERSION (3, 22, 0)
      if (x_gtk_use_window_move)
	{
#endif
	  /* Handle negative positions without consulting
	     gtk_window_parse_geometry (Bug#25851).  The position will
	     be off by scrollbar width + window manager decorations.  */
	  if (f->size_hint_flags & XNegative)
	    f->left_pos = (x_display_pixel_width (FRAME_DISPLAY_INFO (f))
			   - FRAME_PIXEL_WIDTH (f) + f->left_pos);

	  if (f->size_hint_flags & YNegative)
	    f->top_pos = (x_display_pixel_height (FRAME_DISPLAY_INFO (f))
			  - FRAME_PIXEL_HEIGHT (f) + f->top_pos);

	  /* GTK works in scaled pixels, so convert from X pixels.  */
	  gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
			   f->left_pos / scale, f->top_pos / scale);

	  /* Reset size hint flags.  */
	  f->size_hint_flags &= ~ (XNegative | YNegative);
# if ! GTK_CHECK_VERSION (3, 22, 0)
	}
      else
	{
          /* GTK works in scaled pixels, so convert from X pixels.  */
	  int left = f->left_pos / scale;
	  int xneg = f->size_hint_flags & XNegative;
	  int top = f->top_pos / scale;
	  int yneg = f->size_hint_flags & YNegative;
	  char geom_str[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
	  guint id;

	  if (xneg)
	    left = -left;
	  if (yneg)
	    top = -top;

	  sprintf (geom_str, "=%dx%d%c%d%c%d",
		   FRAME_PIXEL_WIDTH (f),
		   FRAME_PIXEL_HEIGHT (f),
		   (xneg ? '-' : '+'), left,
		   (yneg ? '-' : '+'), top);

	  /* Silence warning about visible children.  */
	  id = g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL
				  | G_LOG_FLAG_RECURSION, my_log_handler, NULL);

	  if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
					  geom_str))
	    fprintf (stderr, "Failed to parse: '%s'\n", geom_str);

	  g_log_remove_handler ("Gtk", id);
	}
#endif
    }
}

/* Function to handle resize of our frame.  As we have a Gtk+ tool bar
   and a Gtk+ menu bar, we get resize events for the edit part of the
   frame only.  We let Gtk+ deal with the Gtk+ parts.
   F is the frame to resize.
   PIXELWIDTH, PIXELHEIGHT is the new size in pixels.  */

void
xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
{
  int width, height;

  if (pixelwidth == -1 && pixelheight == -1)
    {
      if (FRAME_GTK_WIDGET (f) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f)))
	gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f)),
				 0, 0, &pixelwidth, &pixelheight);
      else
	return;
    }

  width = FRAME_PIXEL_TO_TEXT_WIDTH (f, pixelwidth);
  height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelheight);

  frame_size_history_add
    (f, Qxg_frame_resized, width, height, Qnil);

  if (width != FRAME_TEXT_WIDTH (f)
      || height != FRAME_TEXT_HEIGHT (f)
      || pixelwidth != FRAME_PIXEL_WIDTH (f)
      || pixelheight != FRAME_PIXEL_HEIGHT (f))
    {
      x_clear_under_internal_border (f);
      change_frame_size (f, width, height, 0, 1, 0, 1);
      SET_FRAME_GARBAGED (f);
      cancel_mouse_face (f);
    }
}

/* Resize the outer window of frame F after changing the height.
   COLUMNS/ROWS is the size the edit area shall have after the resize.  */

void
xg_frame_set_char_size (struct frame *f, int width, int height)
{
  int pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
  int pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
  Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
  gint gwidth, gheight;
  int totalheight
    = pixelheight + FRAME_TOOLBAR_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f);
  int totalwidth = pixelwidth + FRAME_TOOLBAR_WIDTH (f);

  if (FRAME_PIXEL_HEIGHT (f) == 0)
    return;

  gtk_window_get_size (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
		       &gwidth, &gheight);

  /* Do this before resize, as we don't know yet if we will be resized.  */
  x_clear_under_internal_border (f);

  totalheight /= xg_get_scale (f);
  totalwidth /= xg_get_scale (f);

  x_wm_set_size_hint (f, 0, 0);

  /* Resize the top level widget so rows and columns remain constant.

     When the frame is fullheight and we only want to change the width
     or it is fullwidth and we only want to change the height we should
     be able to preserve the fullscreen property.  However, due to the
     fact that we have to send a resize request anyway, the window
     manager will abolish it.  At least the respective size should
     remain unchanged but giving the frame back its normal size will
     be broken ... */
  if (EQ (fullscreen, Qfullwidth) && width == FRAME_TEXT_WIDTH (f))
    {
      frame_size_history_add
	(f, Qxg_frame_set_char_size_1, width, height,
	 list2 (make_number (gheight), make_number (totalheight)));

      gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
			 gwidth, totalheight);
    }
  else if (EQ (fullscreen, Qfullheight) && height == FRAME_TEXT_HEIGHT (f))
    {
      frame_size_history_add
	(f, Qxg_frame_set_char_size_2, width, height,
	 list2 (make_number (gwidth), make_number (totalwidth)));

      gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
			 totalwidth, gheight);
    }
  else
    {
      frame_size_history_add
	(f, Qxg_frame_set_char_size_3, width, height,
	 list2 (make_number (totalwidth), make_number (totalheight)));

      gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
			 totalwidth, totalheight);
      fullscreen = Qnil;
    }

  SET_FRAME_GARBAGED (f);
  cancel_mouse_face (f);