src/xwidget.c

   1 /* Support for embedding graphical components in a buffer.
   2
   3 Copyright (C) 2011-2016 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software: you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation, either version 3 of the License, or
  10 (at your option) any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include <config.h>
  21
  22
  23 #include <signal.h>
  24
  25 #include <stdio.h>
  26 #include <setjmp.h>
  27 #ifdef HAVE_X_WINDOWS
  28
  29 #include "lisp.h"
  30 #include "blockinput.h"
  31 #include "syssignal.h"
  32
  33 #include "xterm.h"
  34 #include <X11/cursorfont.h>
  35
  36 #ifndef makedev
  37 # include <sys/types.h>
  38 #endif
  39
  40 #ifdef BSD_SYSTEM
  41 # include <sys/ioctl.h>
  42 #endif
  43
  44 #include "systime.h"
  45
  46 #ifndef INCLUDED_FCNTL
  47 # include <fcntl.h>
  48 #endif
  49 #include <ctype.h>
  50 #include <errno.h>
  51 #include <setjmp.h>
  52 #include <sys/stat.h>
  53
  54 #include "charset.h"
  55 #include "character.h"
  56 #include "coding.h"
  57 #include "ccl.h"
  58 #include "frame.h"
  59 #include "dispextern.h"
  60 #include "fontset.h"
  61 #include "termhooks.h"
  62 #include "termopts.h"
  63 #include "termchar.h"
  64 #include "disptab.h"
  65 #include "buffer.h"
  66 #include "window.h"
  67 #include "keyboard.h"
  68 #include "intervals.h"
  69 #include "process.h"
  70 #include "atimer.h"
  71 #include "keymap.h"
  72
  73
  74 #ifdef USE_X_TOOLKIT
  75 #include <X11/Shell.h>
  76 #endif
  77 #include <X11/extensions/Xcomposite.h>
  78 #include <X11/extensions/Xrender.h>
  79 #include <cairo.h>
  80 #ifdef HAVE_SYS_TIME_H
  81 #include <sys/time.h>
  82 #endif
  83 #ifdef HAVE_UNISTD_H
  84 #include <unistd.h>
  85 #endif
  86
  87 #include "gtkutil.h"
  88 #include "font.h"
  89 #endif /* HAVE_X_WINDOWS */
  90
  91 #include <gtk/gtk.h>
  92 #include <gdk/gdk.h>
  93
  94 #include <gtk/gtkx.h>
  95
  96 #include "emacsgtkfixed.h"
  97
  98 #include <wchar.h>
  99
 100 #include <webkit/webkitwebview.h>
 101 #include <webkit/webkitwebplugindatabase.h>
 102 #include <webkit/webkitwebplugin.h>
 103 #include <webkit/webkitglobals.h>
 104 #include <webkit/webkitwebnavigationaction.h>
 105 #include <webkit/webkitdownload.h>
 106 #include <webkit/webkitwebpolicydecision.h>
 107
 108 #include "xwidget.h"
 109
 110 static struct xwidget *
 111 allocate_xwidget (void)
 112 {
 113   return ALLOCATE_PSEUDOVECTOR (struct xwidget, height, PVEC_XWIDGET);
 114 }
 115
 116 static struct xwidget_view *
 117 allocate_xwidget_view (void)
 118 {
 119   return ALLOCATE_PSEUDOVECTOR (struct xwidget_view, redisplayed,
 120                                 PVEC_XWIDGET_VIEW);
 121 }
 122
 123 #define XSETXWIDGET(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_XWIDGET))
 124 #define XSETXWIDGET_VIEW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_XWIDGET_VIEW))
 125
 126 struct xwidget_view *xwidget_view_lookup (struct xwidget *, struct window *);
 127 Lisp_Object xwidget_spec_value (Lisp_Object , Lisp_Object , int *);
 128 gboolean offscreen_damage_event (GtkWidget * , GdkEvent * , gpointer );
 129 void webkit_document_load_finished_cb (WebKitWebView *, WebKitWebFrame *,
 130                                        gpointer );
 131 gboolean webkit_download_cb (WebKitWebView *, WebKitDownload *, gpointer);
 132
 133 gboolean
 134 webkit_mime_type_policy_typedecision_requested_cb (WebKitWebView *,
 135                                                    WebKitWebFrame *,
 136                                                    WebKitNetworkRequest *,
 137                                                    gchar *,
 138                                                    WebKitWebPolicyDecision *,
 139                                                    gpointer);
 140
 141 gboolean
 142 webkit_new_window_policy_decision_requested_cb (WebKitWebView *,
 143                                                 WebKitWebFrame *,
 144                                                 WebKitNetworkRequest *,
 145                                                 WebKitWebNavigationAction *,
 146                                                 WebKitWebPolicyDecision *,
 147                                                 gpointer);
 148
 149 gboolean
 150 webkit_navigation_policy_decision_requested_cb (WebKitWebView *,
 151                                                 WebKitWebFrame *,
 152                                                 WebKitNetworkRequest *,
 153                                                 WebKitWebNavigationAction *,
 154                                                 WebKitWebPolicyDecision *,
 155                                                 gpointer);
 156
 157
 158
 159 DEFUN ("make-xwidget",
 160        Fmake_xwidget, Smake_xwidget,
 161        7, 8, 0,
 162        doc: /* Make an xwidget from BEG to END of TYPE.
 163
 164 If BUFFER is nil it uses the current
 165 buffer. If BUFFER is a string and no such
 166 buffer exists, it is created.
 167
 168 TYPE is a symbol which can take one of the
 169 following values:
 170
 171 - webkit_osr
 172
 173 Returns the newly constructed xwidget, or nil if construction
 174 fails.  */)
 175   (Lisp_Object beg, Lisp_Object end,
 176   Lisp_Object type,
 177   Lisp_Object title,
 178   Lisp_Object width, Lisp_Object height,
 179   Lisp_Object arguments, Lisp_Object buffer)
 180 {
 181   //should work a bit like "make-button"(make-button BEG END &rest PROPERTIES)
 182   // arg "type" and fwd should be keyword args eventually
 183   //(make-xwidget 3 3 'button "oei" 31 31 nil)
 184   //(xwidget-info (car xwidget-list))
 185   struct xwidget *xw = allocate_xwidget ();
 186   Lisp_Object val;
 187   xw->type = type;
 188   xw->title = title;
 189   if (NILP (buffer))
 190     buffer = Fcurrent_buffer ();        // no need to gcpro because
 191                                         // Fcurrent_buffer doesn't
 192                                         // call Feval/eval_sub.
 193   else
 194     buffer = Fget_buffer_create (buffer);
 195   xw->buffer = buffer;
 196
 197   xw->height = XFASTINT (height);
 198   xw->width = XFASTINT (width);
 199   xw->kill_without_query = 0;
 200   XSETXWIDGET (val, xw);        // set the vectorlike_header of VAL
 201                                 // with the correct value
 202   Vxwidget_list = Fcons (val, Vxwidget_list);
 203   xw->widgetwindow_osr = NULL;
 204   xw->widget_osr = NULL;
 205   xw->plist = Qnil;
 206
 207
 208   if (EQ (xw->type, Qwebkit_osr))
 209     {
 210       block_input ();
 211       xw->widgetwindow_osr = gtk_offscreen_window_new ();
 212       gtk_window_resize (GTK_WINDOW (xw->widgetwindow_osr), xw->width,
 213                          xw->height);
 214       xw->widgetscrolledwindow_osr = NULL;      //webkit osr is the
 215                                                 //only scrolled
 216                                                 //component atm
 217
 218       if (EQ (xw->type, Qwebkit_osr))
 219         {
 220           xw->widgetscrolledwindow_osr = gtk_scrolled_window_new (NULL, NULL);
 221           gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW
 222                                                       (xw->
 223                                                        widgetscrolledwindow_osr),
 224                                                       xw->height);
 225           gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW
 226                                                      (xw->
 227                                                       widgetscrolledwindow_osr),
 228                                                      xw->width);
 229           gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW
 230                                           (xw->widgetscrolledwindow_osr),
 231                                           GTK_POLICY_ALWAYS,
 232                                           GTK_POLICY_ALWAYS);
 233
 234           xw->widget_osr = webkit_web_view_new ();
 235           gtk_container_add (GTK_CONTAINER (xw->widgetscrolledwindow_osr),
 236                              GTK_WIDGET (WEBKIT_WEB_VIEW (xw->widget_osr)));
 237         }
 238
 239       gtk_widget_set_size_request (GTK_WIDGET (xw->widget_osr), xw->width,
 240                                    xw->height);
 241
 242       if (EQ (xw->type, Qwebkit_osr))
 243         {
 244           gtk_container_add (GTK_CONTAINER (xw->widgetwindow_osr),
 245                              xw->widgetscrolledwindow_osr);
 246         }
 247       else
 248         {
 249           gtk_container_add (GTK_CONTAINER (xw->widgetwindow_osr),
 250                              xw->widget_osr);
 251         }
 252
 253       gtk_widget_show (xw->widget_osr);
 254       gtk_widget_show (xw->widgetwindow_osr);
 255       gtk_widget_show (xw->widgetscrolledwindow_osr);
 256
 257       /* store some xwidget data in the gtk widgets for convenient
 258          retrieval in the event handlers. */
 259       g_object_set_data (G_OBJECT (xw->widget_osr), XG_XWIDGET,
 260                          (gpointer) (xw));
 261       g_object_set_data (G_OBJECT (xw->widgetwindow_osr), XG_XWIDGET,
 262                          (gpointer) (xw));
 263
 264       /* signals */
 265       if (EQ (xw->type, Qwebkit_osr))
 266         {
 267           g_signal_connect (G_OBJECT (xw->widget_osr),
 268                             "document-load-finished",
 269                             G_CALLBACK
 270                             (webkit_document_load_finished_cb), xw);
 271
 272           g_signal_connect (G_OBJECT (xw->widget_osr),
 273                             "download-requested",
 274                             G_CALLBACK (webkit_download_cb), xw);
 275
 276           g_signal_connect (G_OBJECT (xw->widget_osr),
 277                             "mime-type-policy-decision-requested",
 278                             G_CALLBACK
 279                             (webkit_mime_type_policy_typedecision_requested_cb),
 280                             xw);
 281
 282           g_signal_connect (G_OBJECT (xw->widget_osr),
 283                             "new-window-policy-decision-requested",
 284                             G_CALLBACK
 285                             (webkit_new_window_policy_decision_requested_cb),
 286                             xw);
 287
 288           g_signal_connect (G_OBJECT (xw->widget_osr),
 289                             "navigation-policy-decision-requested",
 290                             G_CALLBACK
 291                             (webkit_navigation_policy_decision_requested_cb),
 292                             xw);
 293         }
 294
 295       unblock_input ();
 296
 297     }
 298
 299   return val;
 300 }
 301
 302 DEFUN ("get-buffer-xwidgets", Fget_buffer_xwidgets, Sget_buffer_xwidgets,
 303        1, 1, 0,
 304        doc: /* Return a list of xwidgets associated with BUFFER.
 305 BUFFER  may be a buffer or the name of one.  */)
 306   (Lisp_Object buffer)
 307 {
 308   Lisp_Object xw, tail, xw_list;
 309
 310   if (NILP (buffer))
 311     return Qnil;
 312   buffer = Fget_buffer (buffer);
 313   if (NILP (buffer))
 314     return Qnil;
 315
 316   xw_list = Qnil;
 317
 318   for (tail = Vxwidget_list; CONSP (tail); tail = XCDR (tail))
 319     {
 320       xw = XCAR (tail);
 321       if (XWIDGETP (xw) && EQ (Fxwidget_buffer (xw), buffer))
 322         xw_list = Fcons (xw, xw_list);
 323     }
 324   return xw_list;
 325 }
 326
 327 static int
 328 xwidget_hidden (struct xwidget_view *xv)
 329 {
 330   return xv->hidden;
 331 }
 332
 333
 334
 335 static void
 336 xwidget_show_view (struct xwidget_view *xv)
 337 {
 338   xv->hidden = 0;
 339   gtk_widget_show (xv->widgetwindow);
 340   gtk_fixed_move (GTK_FIXED (xv->emacswindow),
 341                   xv->widgetwindow,
 342                   xv->x + xv->clip_left,
 343                   xv->y + xv->clip_top);
 344 }
 345
 346
 347 /* Hide an xvidget view.  */
 348 static void
 349 xwidget_hide_view (struct xwidget_view *xv)
 350 {
 351   xv->hidden = 1;
 352   gtk_fixed_move (GTK_FIXED (xv->emacswindow), xv->widgetwindow,
 353                   10000, 10000);
 354 }
 355
 356
 357
 358 /* When the off-screen webkit master view changes this signal is called.
 359    It copies the bitmap from the off-screen instance.  */
 360 gboolean
 361 offscreen_damage_event (GtkWidget * widget, GdkEvent * event,
 362                         gpointer xv_widget)
 363 {
 364   // Queue a redraw of onscreen widget.
 365   // There is a guard against receiving an invalid widget,
 366   // which should only happen if we failed to remove the
 367   // specific signal handler for the damage event.
 368   if (GTK_IS_WIDGET (xv_widget))
 369     gtk_widget_queue_draw (GTK_WIDGET (xv_widget));
 370   else
 371     printf ("Warning, offscreen_damage_event received invalid xv pointer:%p\n",
 372             (void *) xv_widget);
 373
 374   return FALSE;
 375 }
 376
 377 static void
 378 store_xwidget_event_string (struct xwidget *xw, const char *eventname,
 379                             const char *eventstr)
 380 {
 381   struct input_event event;
 382   Lisp_Object xwl;
 383   XSETXWIDGET (xwl, xw);
 384   EVENT_INIT (event);
 385   event.kind = XWIDGET_EVENT;
 386   event.frame_or_window = Qnil;
 387
 388   event.arg = Qnil;
 389   event.arg = Fcons (build_string (eventstr), event.arg);
 390   event.arg = Fcons (xwl, event.arg);
 391   event.arg = Fcons (intern (eventname), event.arg);
 392   kbd_buffer_store_event (&event);
 393
 394 }
 395
 396 //TODO deprecated, use load-status
 397 void
 398 webkit_document_load_finished_cb (WebKitWebView * webkitwebview,
 399                                   WebKitWebFrame * arg1,
 400                                   gpointer data)
 401 {
 402   struct xwidget *xw =
 403     (struct xwidget *) g_object_get_data (G_OBJECT (webkitwebview),
 404                                           XG_XWIDGET);
 405
 406   store_xwidget_event_string (xw, "document-load-finished", "");
 407 }
 408
 409 gboolean
 410 webkit_download_cb (WebKitWebView * webkitwebview,
 411                     WebKitDownload * arg1,
 412                     gpointer data)
 413 {
 414   struct xwidget *xw =
 415     (struct xwidget *) g_object_get_data (G_OBJECT (webkitwebview),
 416                                           XG_XWIDGET);
 417   store_xwidget_event_string (xw, "download-requested",
 418                               webkit_download_get_uri (arg1));
 419
 420   return FALSE;
 421 }
 422
 423 gboolean
 424 webkit_mime_type_policy_typedecision_requested_cb (WebKitWebView *webView,
 425                                                    WebKitWebFrame *frame,
 426                                                    WebKitNetworkRequest * request,
 427                                                    gchar * mimetype,
 428                                                    WebKitWebPolicyDecision *policy_decision,
 429                                                    gpointer user_data)
 430 {
 431   // This function makes webkit send a download signal for all unknown
 432   // mime types. TODO Defer the decision to lisp, so that its possible
 433   // to make Emacs handle teext mime for instance.xs
 434   if (!webkit_web_view_can_show_mime_type (webView, mimetype))
 435     {
 436       webkit_web_policy_decision_download (policy_decision);
 437       return TRUE;
 438     }
 439   else
 440     {
 441       return FALSE;
 442     }
 443 }
 444
 445
 446 gboolean
 447 webkit_new_window_policy_decision_requested_cb (WebKitWebView *webView,
 448                                                 WebKitWebFrame *frame,
 449                                                 WebKitNetworkRequest *request,
 450                                                 WebKitWebNavigationAction *navigation_action,
 451                                                 WebKitWebPolicyDecision *policy_decision,
 452                                                 gpointer user_data)
 453 {
 454   struct xwidget *xw =
 455     (struct xwidget *) g_object_get_data (G_OBJECT (webView), XG_XWIDGET);
 456   webkit_web_navigation_action_get_original_uri (navigation_action);
 457
 458   store_xwidget_event_string (xw, "new-window-policy-decision-requested",
 459                               webkit_web_navigation_action_get_original_uri
 460                               (navigation_action));
 461   return FALSE;
 462 }
 463
 464 gboolean
 465 webkit_navigation_policy_decision_requested_cb (WebKitWebView *webView,
 466                                                 WebKitWebFrame *frame,
 467                                                 WebKitNetworkRequest *request,
 468                                                 WebKitWebNavigationAction *navigation_action,
 469                                                 WebKitWebPolicyDecision * policy_decision,
 470                                                 gpointer user_data)
 471 {
 472   struct xwidget *xw =
 473     (struct xwidget *) g_object_get_data (G_OBJECT (webView), XG_XWIDGET);
 474   store_xwidget_event_string (xw, "navigation-policy-decision-requested",
 475                               webkit_web_navigation_action_get_original_uri
 476                               (navigation_action));
 477   return FALSE;
 478 }
 479
 480 // For gtk3 offscreen rendered widgets.
 481 static gboolean
 482 xwidget_osr_draw_cb (GtkWidget * widget, cairo_t * cr, gpointer data)
 483 {
 484   struct xwidget *xw =
 485     (struct xwidget *) g_object_get_data (G_OBJECT (widget), XG_XWIDGET);
 486   struct xwidget_view *xv =
 487     (struct xwidget_view *) g_object_get_data (G_OBJECT (widget),
 488                                                XG_XWIDGET_VIEW);
 489
 490   cairo_rectangle (cr, 0, 0, xv->clip_right, xv->clip_bottom);
 491   cairo_clip (cr);
 492
 493   if (xw->widgetscrolledwindow_osr != NULL)
 494     gtk_widget_draw (xw->widgetscrolledwindow_osr, cr);
 495   else
 496     gtk_widget_draw (xw->widget_osr, cr);
 497   return FALSE;
 498 }
 499
 500 static gboolean
 501 xwidget_osr_event_forward (GtkWidget * widget,
 502                            GdkEvent * event,
 503                            gpointer user_data)
 504 {
 505   /* Copy events that arrive at the outer widget to the offscreen widget. */
 506   struct xwidget *xw =
 507     (struct xwidget *) g_object_get_data (G_OBJECT (widget), XG_XWIDGET);
 508   GdkEvent *eventcopy = gdk_event_copy (event);
 509   eventcopy->any.window = gtk_widget_get_window (xw->widget_osr);
 510
 511   //TODO This might leak events. They should be deallocated later,
 512   //perhaps in xwgir_event_cb
 513   gtk_main_do_event (eventcopy);
 514   return TRUE;                  //dont propagate this event furter
 515 }
 516
 517
 518 static gboolean
 519 xwidget_osr_event_set_embedder (GtkWidget * widget,
 520                                 GdkEvent * event, gpointer data)
 521 {
 522   struct xwidget_view *xv = (struct xwidget_view *) data;
 523   struct xwidget *xww = XXWIDGET (xv->model);
 524   gdk_offscreen_window_set_embedder (gtk_widget_get_window
 525                                      (xww->widgetwindow_osr),
 526                                      gtk_widget_get_window (xv->widget));
 527   return FALSE;
 528 }
 529
 530
 531 /* Initializes and does initial placement of an xwidget view on screen. */
 532 static struct xwidget_view *
 533 xwidget_init_view (struct xwidget *xww,
 534                    struct glyph_string *s,
 535                    int x, int y)
 536 {
 537   struct xwidget_view *xv = allocate_xwidget_view ();
 538   Lisp_Object val;
 539
 540   XSETXWIDGET_VIEW (val, xv);
 541   Vxwidget_view_list = Fcons (val, Vxwidget_view_list);
 542
 543   XSETWINDOW (xv->w, s->w);
 544   XSETXWIDGET (xv->model, xww);
 545
 546   if (EQ (xww->type, Qwebkit_osr))
 547     {
 548       xv->widget = gtk_drawing_area_new ();
 549       // Expose event handling.
 550       gtk_widget_set_app_paintable (xv->widget, TRUE);
 551       gtk_widget_add_events (xv->widget, GDK_ALL_EVENTS_MASK);
 552
 553       /* Draw the view on damage-event */
 554       g_signal_connect (G_OBJECT (xww->widgetwindow_osr), "damage-event",
 555                         G_CALLBACK (offscreen_damage_event), xv->widget);
 556
 557       if (EQ (xww->type, Qwebkit_osr))
 558         {
 559           g_signal_connect (G_OBJECT (xv->widget), "button-press-event",
 560                             G_CALLBACK (xwidget_osr_event_forward), NULL);
 561           g_signal_connect (G_OBJECT (xv->widget), "button-release-event",
 562                             G_CALLBACK (xwidget_osr_event_forward), NULL);
 563           g_signal_connect (G_OBJECT (xv->widget), "motion-notify-event",
 564                             G_CALLBACK (xwidget_osr_event_forward), NULL);
 565         }
 566       else
 567         {
 568           // xwgir debug , orthogonal to forwarding
 569           g_signal_connect (G_OBJECT (xv->widget), "enter-notify-event",
 570                             G_CALLBACK (xwidget_osr_event_set_embedder), xv);
 571         }
 572       g_signal_connect (G_OBJECT (xv->widget), "draw",
 573                         G_CALLBACK (xwidget_osr_draw_cb), NULL);
 574     }
 575   // Widget realization.
 576
 577   // Make container widget 1st, and put the actual widget inside the
 578   // container later.  Drawing should crop container window if necessary
 579   // to handle case where xwidget is partially obscured by other Emacs
 580   // windows.  Other containers than gtk_fixed where explored, but
 581   // gtk_fixed had the most predictable behaviour so far.
 582   xv->emacswindow = FRAME_GTK_WIDGET (s->f);
 583   xv->widgetwindow = gtk_fixed_new ();
 584   gtk_widget_set_has_window (xv->widgetwindow, TRUE);
 585   gtk_container_add (GTK_CONTAINER (xv->widgetwindow), xv->widget);
 586
 587   // Store some xwidget data in the gtk widgets.
 588   // The emacs frame.
 589   g_object_set_data (G_OBJECT (xv->widget), XG_FRAME_DATA, (gpointer) (s->f));
 590   // The xwidget.
 591   g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET, (gpointer) (xww));
 592   // The xwidget.
 593   g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET_VIEW, (gpointer) (xv));
 594   // The xwidget window.
 595   g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET, (gpointer) (xww));
 596   // the xwidget view.
 597   g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET_VIEW,
 598                      (gpointer) (xv));
 599
 600
 601   gtk_widget_set_size_request (GTK_WIDGET (xv->widget), xww->width,
 602                                xww->height);
 603   gtk_widget_set_size_request (xv->widgetwindow, xww->width, xww->height);
 604   gtk_fixed_put (GTK_FIXED (FRAME_GTK_WIDGET (s->f)), xv->widgetwindow, x, y);
 605   xv->x = x;
 606   xv->y = y;
 607   gtk_widget_show_all (xv->widgetwindow);
 608
 609
 610   return xv;
 611 }
 612
 613
 614 void
 615 x_draw_xwidget_glyph_string (struct glyph_string *s)
 616 {
 617   /* This method is called by the redisplay engine and places the
 618      xwidget on screen.  Moving and clipping is done here.  Also view
 619      initialization.
 620    */
 621   struct xwidget *xww = s->xwidget;
 622   struct xwidget_view *xv = xwidget_view_lookup (xww, s->w);
 623   int clip_right;
 624   int clip_bottom;
 625   int clip_top;
 626   int clip_left;
 627
 628   int x = s->x;
 629   int y = s->y + (s->height / 2) - (xww->height / 2);
 630   int moved = 0;
 631
 632   /* We do initialization here in the display loop because there is no
 633      other time to know things like window placement etc.
 634    */
 635   xv = xwidget_init_view (xww, s, x, y);
 636
 637   // Calculate clipping, which is used for all manner of onscreen
 638   // xwidget views.  Each widget border can get clipped by other emacs
 639   // objects so there are four clipping variables.
 640   clip_right =
 641     min (xww->width,
 642          WINDOW_RIGHT_EDGE_X (s->w) - x -
 643          WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH (s->w) -
 644          WINDOW_RIGHT_FRINGE_WIDTH (s->w));
 645   clip_left =
 646     max (0,
 647          WINDOW_LEFT_EDGE_X (s->w) - x +
 648          WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (s->w) +
 649          WINDOW_LEFT_FRINGE_WIDTH (s->w));
 650
 651   clip_bottom =
 652     min (xww->height,
 653          WINDOW_BOTTOM_EDGE_Y (s->w) - WINDOW_MODE_LINE_HEIGHT (s->w) - y);
 654   clip_top = max (0, WINDOW_TOP_EDGE_Y (s->w) - y);
 655
 656   // We are conserned with movement of the onscreen area. The area
 657   // might sit still when the widget actually moves.  This happens
 658   // when an Emacs window border moves across a widget window. So, if
 659   // any corner of the outer widget clipping window moves, that counts
 660   // as movement here, even if it looks like no movement happens
 661   // because the widget sits still inside the clipping area.  The
 662   // widget can also move inside the clipping area, which happens
 663   // later
 664   moved = (xv->x + xv->clip_left != x + clip_left)
 665     || ((xv->y + xv->clip_top) != (y + clip_top));
 666   xv->x = x;
 667   xv->y = y;
 668   if (moved) // Has it moved?
 669     {
 670           gtk_fixed_move (GTK_FIXED (FRAME_GTK_WIDGET (s->f)),
 671                           xv->widgetwindow, x + clip_left, y + clip_top);
 672     }
 673   // Clip the widget window if some parts happen to be outside
 674   // drawable area. An Emacs window is not a gtk window. A gtk window
 675   // covers the entire frame. Clipping might have changed even if we
 676   // havent actualy moved, we try figure out when we need to reclip
 677   // for real.
 678   if ((xv->clip_right != clip_right)
 679       || (xv->clip_bottom != clip_bottom)
 680       || (xv->clip_top != clip_top) || (xv->clip_left != clip_left))
 681     {
 682       gtk_widget_set_size_request (xv->widgetwindow, clip_right + clip_left,
 683                                    clip_bottom + clip_top);
 684       gtk_fixed_move (GTK_FIXED (xv->widgetwindow), xv->widget, -clip_left,
 685                       -clip_top);
 686
 687       xv->clip_right = clip_right;
 688       xv->clip_bottom = clip_bottom;
 689       xv->clip_top = clip_top;
 690       xv->clip_left = clip_left;
 691     }
 692   // If emacs wants to repaint the area where the widget lives, queue
 693   // a redraw. It seems its possible to get out of sync with emacs
 694   // redraws so emacs background sometimes shows up instead of the
 695   // xwidgets background. It's just a visual glitch though.
 696   if (!xwidget_hidden (xv))
 697     {
 698       gtk_widget_queue_draw (xv->widgetwindow);
 699       gtk_widget_queue_draw (xv->widget);
 700     }
 701 }
 702
 703
 704 // Macro that checks WEBKIT_IS_WEB_VIEW(xw->widget_osr) first
 705 #define WEBKIT_FN_INIT()                        \
 706   struct xwidget* xw; \
 707   CHECK_XWIDGET (xwidget); \
 708  if (NILP (xwidget)) {printf("ERROR xwidget nil\n"); return Qnil;};    \
 709   xw = XXWIDGET (xwidget);                                                    \
 710   if (NULL == xw) printf("ERROR xw is 0\n");                               \
 711   if ((NULL == xw->widget_osr) || !WEBKIT_IS_WEB_VIEW(xw->widget_osr)){  \
 712     printf ("ERROR xw->widget_osr does not hold a webkit instance\n");\
 713     return Qnil;\
 714   };
 715
 716
 717 DEFUN ("xwidget-webkit-goto-uri",
 718        Fxwidget_webkit_goto_uri, Sxwidget_webkit_goto_uri,
 719        2, 2, 0,
 720        doc: /* Make the xwidget webkit instance referenced by XWIDGET
 721 browse URI. */)
 722   (Lisp_Object xwidget, Lisp_Object uri)
 723 {
 724   WEBKIT_FN_INIT ();
 725   CHECK_STRING (uri);
 726   webkit_web_view_load_uri (WEBKIT_WEB_VIEW (xw->widget_osr), SSDATA (uri));
 727   return Qnil;
 728 }
 729
 730
 731 DEFUN ("xwidget-webkit-execute-script",
 732        Fxwidget_webkit_execute_script, Sxwidget_webkit_execute_script,
 733        2, 2, 0,
 734        doc: /* Make the Webkit XWIDGET execute javascript SCRIPT.  */)
 735   (Lisp_Object xwidget, Lisp_Object script)
 736 {
 737   WEBKIT_FN_INIT ();
 738   CHECK_STRING (script);
 739   webkit_web_view_execute_script (WEBKIT_WEB_VIEW (xw->widget_osr),
 740                                   SSDATA (script));
 741   return Qnil;
 742 }
 743
 744 DEFUN ("xwidget-webkit-get-title",
 745        Fxwidget_webkit_get_title, Sxwidget_webkit_get_title,
 746        1, 1, 0,
 747        doc: /* Returns the title from the Webkit instance in XWIDGET.
 748 This can be used to work around the lack of a return value from the
 749 exec method.  */ )
 750   (Lisp_Object xwidget)
 751 {
 752   // TODO support multibyte strings
 753   WEBKIT_FN_INIT ();
 754   const gchar *str =
 755     webkit_web_view_get_title (WEBKIT_WEB_VIEW (xw->widget_osr));
 756   if (str == 0)
 757     {
 758       // TODO maybe return Qnil instead. I suppose webkit returns
 759       // nullpointer when doc is not properly loaded or something
 760       return build_string ("");
 761     }
 762   return build_string (str);
 763 }
 764
 765 DEFUN ("xwidget-resize", Fxwidget_resize, Sxwidget_resize, 3, 3, 0,
 766        doc: /* Resize XWIDGET.  NEW_WIDTH NEW_HEIGHT defines the new
 767 size. */ )
 768   (Lisp_Object xwidget, Lisp_Object new_width, Lisp_Object new_height)
 769 {
 770   CHECK_XWIDGET (xwidget);
 771   struct xwidget *xw = XXWIDGET (xwidget);
 772   struct xwidget_view *xv;
 773   int w, h;
 774
 775   CHECK_NUMBER (new_width);
 776   CHECK_NUMBER (new_height);
 777   w = XFASTINT (new_width);
 778   h = XFASTINT (new_height);
 779
 780   xw->width = w;
 781   xw->height = h;
 782   // If there is a offscreen widget resize it 1st.
 783   if (xw->widget_osr)
 784     {
 785       gtk_widget_set_size_request (GTK_WIDGET (xw->widget_osr),
 786                                    xw->width, xw->height);      //minimum size
 787       gtk_window_resize (GTK_WINDOW (xw->widgetwindow_osr), xw->width,
 788                          xw->height);
 789       gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW
 790                                                   (xw->
 791                                                    widgetscrolledwindow_osr),
 792                                                   xw->height);
 793       gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW
 794                                                  (xw->
 795                                                   widgetscrolledwindow_osr),
 796                                                  xw->width);
 797
 798       gtk_container_resize_children (GTK_CONTAINER (xw->widgetwindow_osr));
 799
 800     }
 801
 802   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail); tail = XCDR (tail))
 803     {
 804       if (XWIDGET_VIEW_P (XCAR (tail)))
 805         {
 806           xv = XXWIDGET_VIEW (XCAR (tail));
 807           if (XXWIDGET (xv->model) == xw)
 808               gtk_widget_set_size_request (GTK_WIDGET (xv->widget), xw->width,
 809                                            xw->height);
 810         }
 811     }
 812
 813   return Qnil;
 814 }
 815
 816
 817
 818 DEFUN ("xwidget-set-adjustment",
 819        Fxwidget_set_adjustment, Sxwidget_set_adjustment, 4, 4, 0,
 820        doc: /* Set native scrolling for XWIDGET. AXIS can be 'vertical or
 821 'horizontal. If RELATIVE is t, scroll relative, otherwise absolutely.
 822 VALUE is the amount to scroll, either relatively or absolutely.  */)
 823   (Lisp_Object xwidget, Lisp_Object axis, Lisp_Object relative,
 824    Lisp_Object value)
 825 {
 826   CHECK_XWIDGET (xwidget);
 827   struct xwidget *xw = XXWIDGET (xwidget);
 828   GtkAdjustment *adjustment;
 829   float final_value = 0.0;
 830
 831   adjustment =
 832     gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW
 833                                          (xw->widgetscrolledwindow_osr));
 834   if (EQ (Qvertical, axis))
 835     {
 836       adjustment =
 837         gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW
 838                                              (xw->widgetscrolledwindow_osr));
 839     }
 840   if (EQ (Qhorizontal, axis))
 841     {
 842       adjustment =
 843         gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW
 844                                              (xw->widgetscrolledwindow_osr));
 845     }
 846
 847   if (EQ (Qt, relative))
 848     {
 849       final_value = gtk_adjustment_get_value (adjustment) + XFASTINT (value);
 850     }
 851   else
 852     {
 853       final_value = 0.0 + XFASTINT (value);
 854     }
 855
 856   gtk_adjustment_set_value (adjustment, final_value);
 857
 858   return Qnil;
 859 }
 860
 861
 862 DEFUN ("xwidget-size-request",
 863        Fxwidget_size_request, Sxwidget_size_request,
 864        1, 1, 0,
 865        doc: /* Return the desired size of the XWIDGET.
 866
 867 This can be used to read the xwidget desired size, and resizes the
 868 Emacs allocated area accordingly.  */)
 869   (Lisp_Object xwidget)
 870 {
 871   CHECK_XWIDGET (xwidget);
 872   GtkRequisition requisition;
 873   Lisp_Object rv;
 874   gtk_widget_size_request (XXWIDGET (xwidget)->widget_osr, &requisition);
 875   rv = Qnil;
 876   rv = Fcons (make_number (requisition.height), rv);
 877   rv = Fcons (make_number (requisition.width), rv);
 878   return rv;
 879
 880 }
 881
 882 DEFUN ("xwidgetp",
 883        Fxwidgetp, Sxwidgetp,
 884        1, 1, 0,
 885        doc: /* Return t if OBJECT is a xwidget.  */)
 886   (Lisp_Object object)
 887 {
 888   return XWIDGETP (object) ? Qt : Qnil;
 889 }
 890
 891 DEFUN ("xwidget-view-p",
 892        Fxwidget_view_p, Sxwidget_view_p,
 893        1, 1, 0,
 894        doc: /* Return t if OBJECT is a xwidget-view.  */)
 895   (Lisp_Object object)
 896 {
 897   return XWIDGET_VIEW_P (object) ? Qt : Qnil;
 898 }
 899
 900 DEFUN ("xwidget-info",
 901        Fxwidget_info, Sxwidget_info,
 902        1, 1, 0,
 903        doc: /* Return XWIDGET properties in a vector.  Currently [TYPE
 904 TITLE WIDTH HEIGHT]. */)
 905   (Lisp_Object xwidget)
 906 {
 907   CHECK_XWIDGET (xwidget);
 908   Lisp_Object info, n;
 909   struct xwidget *xw = XXWIDGET (xwidget);
 910
 911   info = Fmake_vector (make_number (4), Qnil);
 912   ASET (info, 0, xw->type);
 913   ASET (info, 1, xw->title);
 914   XSETFASTINT (n, xw->width);
 915   ASET (info, 2, n);
 916   XSETFASTINT (n, xw->height);
 917   ASET (info, 3, n);
 918
 919   return info;
 920 }
 921
 922 DEFUN ("xwidget-view-info",
 923        Fxwidget_view_info, Sxwidget_view_info,
 924        1, 1, 0,
 925        doc: /* Return properties of XWIDGET-VIEW in a vector.
 926 Currently [X Y CLIP_RIGHT CLIP_BOTTOM CLIP_TOP CLIP_LEFT] */)
 927   (Lisp_Object xwidget_view)
 928 {
 929   CHECK_XWIDGET_VIEW (xwidget_view);
 930   struct xwidget_view *xv = XXWIDGET_VIEW (xwidget_view);
 931   Lisp_Object info;
 932
 933   info = Fmake_vector (make_number (6), Qnil);
 934   ASET (info, 0, make_number (xv->x));
 935   ASET (info, 1, make_number (xv->y));
 936   ASET (info, 2, make_number (xv->clip_right));
 937   ASET (info, 3, make_number (xv->clip_bottom));
 938   ASET (info, 4, make_number (xv->clip_top));
 939   ASET (info, 5, make_number (xv->clip_left));
 940
 941   return info;
 942 }
 943
 944 DEFUN ("xwidget-view-model",
 945        Fxwidget_view_model, Sxwidget_view_model,
 946        1, 1, 0,
 947        doc:  /* Return the model associated with XWIDGET-VIEW. */)
 948   (Lisp_Object xwidget_view)
 949 {
 950   CHECK_XWIDGET_VIEW (xwidget_view);
 951   return XXWIDGET_VIEW (xwidget_view)->model;
 952 }
 953
 954 DEFUN ("xwidget-view-window",
 955        Fxwidget_view_window, Sxwidget_view_window,
 956        1, 1, 0,
 957        doc:  /* Return the window of XWIDGET-VIEW. */)
 958   (Lisp_Object xwidget_view)
 959 {
 960   CHECK_XWIDGET_VIEW (xwidget_view);
 961   return XXWIDGET_VIEW (xwidget_view)->w;
 962 }
 963
 964
 965 DEFUN ("delete-xwidget-view",
 966        Fdelete_xwidget_view, Sdelete_xwidget_view,
 967        1, 1, 0,
 968        doc:  /* Delete the XWIDGET-VIEW. */)
 969   (Lisp_Object xwidget_view)
 970 {
 971   CHECK_XWIDGET_VIEW (xwidget_view);
 972   struct xwidget_view *xv = XXWIDGET_VIEW (xwidget_view);
 973   gtk_widget_destroy (xv->widgetwindow);
 974   Vxwidget_view_list = Fdelq (xwidget_view, Vxwidget_view_list);
 975   // xv->model still has signals pointing to the view. There can be
 976   // several views. Find the matching signals and delete them all.
 977   g_signal_handlers_disconnect_matched  (XXWIDGET (xv->model)->widgetwindow_osr,
 978                                          G_SIGNAL_MATCH_DATA,
 979                                          0, 0, 0, 0,
 980                                          xv->widget);
 981   return Qnil;
 982 }
 983
 984 DEFUN ("xwidget-view-lookup",
 985        Fxwidget_view_lookup, Sxwidget_view_lookup,
 986        1, 2, 0,
 987        doc: /* Return the xwidget-view associated with XWIDGET in
 988 WINDOW if specified, otherwise it uses the selected window. Return nil
 989 if no association is found.  */)
 990   (Lisp_Object xwidget, Lisp_Object window)
 991 {
 992   CHECK_XWIDGET (xwidget);
 993
 994   if (NILP (window))
 995     window = Fselected_window ();
 996   CHECK_WINDOW (window);
 997
 998   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail);
 999        tail = XCDR (tail))
1000     {
1001       Lisp_Object xwidget_view = XCAR (tail);
1002       if (EQ (Fxwidget_view_model (xwidget_view), xwidget)
1003           && EQ (Fxwidget_view_window (xwidget_view), window))
1004         return xwidget_view;
1005     }
1006
1007   return Qnil;
1008 }
1009
1010 DEFUN ("xwidget-plist",
1011        Fxwidget_plist, Sxwidget_plist,
1012        1, 1, 0,
1013        doc: /* Return the plist of XWIDGET.  */)
1014   (register Lisp_Object xwidget)
1015 {
1016   CHECK_XWIDGET (xwidget);
1017   return XXWIDGET (xwidget)->plist;
1018 }
1019
1020 DEFUN ("xwidget-buffer",
1021        Fxwidget_buffer, Sxwidget_buffer,
1022        1, 1, 0,
1023        doc: /* Return the buffer of XWIDGET.  */)
1024   (register Lisp_Object xwidget)
1025 {
1026   CHECK_XWIDGET (xwidget);
1027   return XXWIDGET (xwidget)->buffer;
1028 }
1029
1030 DEFUN ("set-xwidget-plist",
1031        Fset_xwidget_plist, Sset_xwidget_plist,
1032        2, 2, 0,
1033        doc: /* Replace the plist of XWIDGET with PLIST.
1034 Returns PLIST.  */)
1035   (register Lisp_Object xwidget, Lisp_Object plist)
1036 {
1037   CHECK_XWIDGET (xwidget);
1038   CHECK_LIST (plist);
1039
1040   XXWIDGET (xwidget)->plist = plist;
1041   return plist;
1042 }
1043
1044 DEFUN ("set-xwidget-query-on-exit-flag",
1045        Fset_xwidget_query_on_exit_flag, Sset_xwidget_query_on_exit_flag,
1046        2, 2, 0,
1047        doc: /* Specify if query is needed for XWIDGET when
1048 Emacs is exited.  If the second argument FLAG is non-nil, Emacs will
1049 queries the user before exiting or killing a buffer if XWIDGET is
1050 running.  This function returns FLAG. */)
1051   (Lisp_Object xwidget, Lisp_Object flag)
1052 {
1053   CHECK_XWIDGET (xwidget);
1054   XXWIDGET (xwidget)->kill_without_query = NILP (flag);
1055   return flag;
1056 }
1057
1058 DEFUN ("xwidget-query-on-exit-flag",
1059        Fxwidget_query_on_exit_flag, Sxwidget_query_on_exit_flag,
1060        1, 1, 0,
1061        doc: /* Return the current value of query-on-exit
1062 flag for XWIDGET. */)
1063   (Lisp_Object xwidget)
1064 {
1065   CHECK_XWIDGET (xwidget);
1066   return (XXWIDGET (xwidget)->kill_without_query ? Qnil : Qt);
1067 }
1068
1069 void
1070 syms_of_xwidget (void)
1071 {
1072
1073   defsubr (&Smake_xwidget);
1074   defsubr (&Sxwidgetp);
1075   DEFSYM (Qxwidgetp, "xwidgetp");
1076   defsubr (&Sxwidget_view_p);
1077   DEFSYM (Qxwidget_view_p, "xwidget-view-p");
1078   defsubr (&Sxwidget_info);
1079   defsubr (&Sxwidget_view_info);
1080   defsubr (&Sxwidget_resize);
1081   defsubr (&Sget_buffer_xwidgets);
1082   defsubr (&Sxwidget_view_model);
1083   defsubr (&Sxwidget_view_window);
1084   defsubr (&Sxwidget_view_lookup);
1085   defsubr (&Sxwidget_query_on_exit_flag);
1086   defsubr (&Sset_xwidget_query_on_exit_flag);
1087
1088 #ifdef HAVE_WEBKIT_OSR
1089   defsubr (&Sxwidget_webkit_goto_uri);
1090   defsubr (&Sxwidget_webkit_execute_script);
1091   defsubr (&Sxwidget_webkit_get_title);
1092   DEFSYM (Qwebkit_osr, "webkit-osr");
1093 #endif
1094
1095   defsubr (&Sxwidget_size_request);
1096   defsubr (&Sdelete_xwidget_view);
1097
1098   defsubr (&Sxwidget_plist);
1099   defsubr (&Sxwidget_buffer);
1100   defsubr (&Sset_xwidget_plist);
1101
1102   defsubr (&Sxwidget_set_adjustment);
1103
1104   DEFSYM (Qxwidget, "xwidget");
1105
1106   DEFSYM (QCxwidget, ":xwidget");
1107   DEFSYM (QCtitle, ":title");
1108
1109   /* Do not forget to update the docstring of make-xwidget if you add
1110      new types. */
1111
1112   DEFSYM (Qvertical, "vertical");
1113   DEFSYM (Qhorizontal, "horizontal");
1114
1115   DEFSYM (QCplist, ":plist");
1116
1117   DEFVAR_LISP ("xwidget-list", Vxwidget_list,
1118                doc:     /* xwidgets list.  */);
1119   Vxwidget_list = Qnil;
1120
1121   DEFVAR_LISP ("xwidget-view-list", Vxwidget_view_list,
1122              doc:       /* xwidget views list.  */);
1123   Vxwidget_view_list = Qnil;
1124
1125   Fprovide (intern ("xwidget-internal"), Qnil);
1126
1127 }
1128
1129
1130 /* Value is non-zero if OBJECT is a valid Lisp xwidget specification.  A
1131    valid xwidget specification is a list whose car is the symbol
1132    `xwidget', and whose rest is a property list.  The property list must
1133    contain a value for key `:type'.  That value must be the name of a
1134    supported xwidget type.  The rest of the property list depends on the
1135    xwidget type.  */
1136
1137 bool
1138 valid_xwidget_spec_p (Lisp_Object object)
1139 {
1140   int valid_p = false;
1141
1142   if (CONSP (object) && EQ (XCAR (object), Qxwidget))
1143       valid_p = true;
1144
1145   return valid_p;
1146 }
1147
1148
1149
1150 /* Find a value associated with key in spec.  */
1151 Lisp_Object
1152 xwidget_spec_value (Lisp_Object spec, Lisp_Object key, int *found)
1153 {
1154   Lisp_Object tail;
1155
1156   eassert (valid_xwidget_spec_p (spec));
1157
1158   for (tail = XCDR (spec);
1159        CONSP (tail) && CONSP (XCDR (tail)); tail = XCDR (XCDR (tail)))
1160     {
1161       if (EQ (XCAR (tail), key))
1162         {
1163           if (found)
1164             *found = 1;
1165           return XCAR (XCDR (tail));
1166         }
1167     }
1168
1169   if (found)
1170     *found = 0;
1171   return Qnil;
1172 }
1173
1174
1175 void
1176 xwidget_view_delete_all_in_window (struct window *w)
1177 {
1178   struct xwidget_view *xv = NULL;
1179   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail);
1180        tail = XCDR (tail))
1181     {
1182       if (XWIDGET_VIEW_P (XCAR (tail)))
1183         {
1184           xv = XXWIDGET_VIEW (XCAR (tail));
1185           if (XWINDOW (xv->w) == w)
1186             {
1187               Fdelete_xwidget_view (XCAR (tail));
1188             }
1189         }
1190     }
1191 }
1192
1193 struct xwidget_view *
1194 xwidget_view_lookup (struct xwidget *xw, struct window *w)
1195 {
1196   Lisp_Object xwidget, window, ret;
1197   XSETXWIDGET (xwidget, xw);
1198   XSETWINDOW (window, w);
1199
1200   ret = Fxwidget_view_lookup (xwidget, window);
1201
1202   return EQ (ret, Qnil) ? NULL : XXWIDGET_VIEW (ret);
1203 }
1204
1205 struct xwidget *
1206 lookup_xwidget (Lisp_Object spec)
1207 {
1208   /* When a xwidget lisp spec is found initialize the C struct that is
1209      used in the C code.  This is done by redisplay so values change
1210      if the spec changes.  So, take special care of one-shot events.
1211    */
1212   int found = 0;
1213   Lisp_Object value;
1214   struct xwidget *xw;
1215
1216   value = xwidget_spec_value (spec, QCxwidget, &found);
1217   xw = XXWIDGET (value);
1218
1219   return xw;
1220 }
1221
1222 /* Set up detection of touched xwidget*/
1223 void
1224 xwidget_start_redisplay (void)
1225 {
1226   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail);
1227        tail = XCDR (tail))
1228     {
1229       if (XWIDGET_VIEW_P (XCAR (tail)))
1230         XXWIDGET_VIEW (XCAR (tail))->redisplayed = 0;
1231     }
1232 }
1233
1234 /* The xwidget was touched during redisplay, so it isn't a candidate
1235    for hiding.  */
1236 void
1237 xwidget_touch (struct xwidget_view *xv)
1238 {
1239   xv->redisplayed = 1;
1240 }
1241
1242 static int
1243 xwidget_touched (struct xwidget_view *xv)
1244 {
1245   return xv->redisplayed;
1246 }
1247
1248 /* Redisplay has ended, now we should hide untouched xwidgets
1249 */
1250 void
1251 xwidget_end_redisplay (struct window *w, struct glyph_matrix *matrix)
1252 {
1253
1254   int i;
1255   int area;
1256
1257   xwidget_start_redisplay ();
1258   // Iterate desired glyph matrix of window here, hide gtk widgets
1259   // not in the desired matrix.
1260
1261   // This only takes care of xwidgets in active windows.  if a window
1262   // goes away from screen xwidget views wust be deleted
1263
1264   //  dump_glyph_matrix (matrix, 2);
1265   for (i = 0; i < matrix->nrows; ++i)
1266     {
1267       //    dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs);
1268       struct glyph_row *row;
1269       row = MATRIX_ROW (matrix, i);
1270       if (row->enabled_p != 0)
1271         {
1272           for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
1273             {
1274               struct glyph *glyph = row->glyphs[area];
1275               struct glyph *glyph_end = glyph + row->used[area];
1276               for (; glyph < glyph_end; ++glyph)
1277                 {
1278                   if (glyph->type == XWIDGET_GLYPH)
1279                     {
1280                       /*
1281                         The only call to xwidget_end_redisplay is in dispnew
1282                          xwidget_end_redisplay (w->current_matrix);
1283                        */
1284                       xwidget_touch (xwidget_view_lookup (glyph->u.xwidget,
1285                                                           w));
1286                     }
1287                 }
1288             }
1289         }
1290     }
1291
1292   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail);
1293        tail = XCDR (tail))
1294     {
1295       if (XWIDGET_VIEW_P (XCAR (tail)))
1296         {
1297           struct xwidget_view *xv = XXWIDGET_VIEW (XCAR (tail));
1298
1299           // "touched" is only meaningful for the current window, so
1300           // disregard other views.
1301           if (XWINDOW (xv->w) == w)
1302             {
1303               if (xwidget_touched (xv))
1304                 xwidget_show_view (xv);
1305               else
1306                 xwidget_hide_view (xv);
1307             }
1308         }
1309     }
1310 }
1311
1312 /* Kill all xwidget in BUFFER. */
1313 void
1314 kill_buffer_xwidgets (Lisp_Object buffer)
1315 {
1316   Lisp_Object tail, xwidget;
1317   for (tail = Fget_buffer_xwidgets (buffer); CONSP (tail); tail = XCDR (tail))
1318     {
1319       xwidget = XCAR (tail);
1320       Vxwidget_list = Fdelq (xwidget, Vxwidget_list);
1321       /* TODO free the GTK things in xw */
1322       {
1323         CHECK_XWIDGET (xwidget);
1324         struct xwidget *xw = XXWIDGET (xwidget);
1325         if (xw->widget_osr && xw->widgetwindow_osr)
1326           {
1327             gtk_widget_destroy (xw->widget_osr);
1328             gtk_widget_destroy (xw->widgetwindow_osr);
1329           }
1330       }
1331     }
1332 }