lisp/xwidget.el

   1 ;;; xwidget.el --- api functions for xwidgets  -*- lexical-binding: t -*-
   2 ;;
   3 ;; Copyright (C) 2011-2016 Free Software Foundation, Inc.
   4 ;;
   5 ;; Author: Joakim Verona (joakim@verona.se)
   6 ;;
   7 ;; This file is part of GNU Emacs.
   8 ;;
   9 ;; GNU Emacs is free software: you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation, either version 3 of the License, or
  12 ;; (at your option) any later version.
  13
  14 ;; GNU Emacs is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  21 ;;
  22 ;; --------------------------------------------------------------------
  23
  24 ;;; Commentary:
  25 ;;
  26 ;; See xwidget.c for more api functions.
  27
  28 ;; This breaks compilation when we don't have xwidgets.
  29 ;; And is pointless when we do, since it's in C and so preloaded.
  30 ;;(require 'xwidget-internal)
  31
  32 ;;; Code:
  33
  34 (require 'cl-lib)
  35 (require 'bookmark)
  36
  37 (declare-function make-xwidget "xwidget.c"
  38                   (type title width height arguments &optional buffer))
  39 (declare-function xwidget-buffer "xwidget.c" (xwidget))
  40 (declare-function xwidget-webkit-get-title "xwidget.c" (xwidget))
  41 (declare-function xwidget-size-request "xwidget.c" (xwidget))
  42 (declare-function xwidget-resize "xwidget.c" (xwidget new-width new-height))
  43 (declare-function xwidget-webkit-execute-script "xwidget.c"
  44                   (xwidget script &optional callback))
  45 (declare-function xwidget-webkit-goto-uri "xwidget.c" (xwidget uri))
  46 (declare-function xwidget-plist "xwidget.c" (xwidget))
  47 (declare-function set-xwidget-plist "xwidget.c" (xwidget plist))
  48 (declare-function xwidget-view-window "xwidget.c" (xwidget-view))
  49 (declare-function xwidget-view-model "xwidget.c" (xwidget-view))
  50 (declare-function delete-xwidget-view "xwidget.c" (xwidget-view))
  51 (declare-function get-buffer-xwidgets "xwidget.c" (buffer))
  52 (declare-function xwidget-query-on-exit-flag "xwidget.c" (xwidget))
  53
  54 (defun xwidget-insert (pos type title width height &optional args)
  55   "Insert an xwidget at position POS.
  56 Supply the xwidget's TYPE, TITLE, WIDTH, and HEIGHT.
  57 See `make-xwidget' for the possible TYPE values.
  58 The usage of optional argument ARGS depends on the xwidget.
  59 This returns the result of `make-xwidget'."
  60   (goto-char pos)
  61   (let ((id (make-xwidget type title width height args)))
  62     (put-text-property (point) (+ 1 (point))
  63                        'display (list 'xwidget ':xwidget id))
  64     id))
  65
  66 (defun xwidget-at (pos)
  67   "Return xwidget at POS."
  68   ;; TODO this function is a bit tedious because the C layer isn't well
  69   ;; protected yet and xwidgetp apparently doesn't work yet.
  70   (let* ((disp (get-text-property pos 'display))
  71          (xw (car (cdr (cdr  disp)))))
  72     ;;(if (xwidgetp  xw) xw nil)
  73     (if (equal 'xwidget (car disp)) xw)))
  74
  75
  76
  77 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  78 ;;; webkit support
  79 (require 'browse-url)
  80 (require 'image-mode);;for some image-mode alike functionality
  81
  82 ;;;###autoload
  83 (defun xwidget-webkit-browse-url (url &optional new-session)
  84   "Ask xwidget-webkit to browse URL.
  85 NEW-SESSION specifies whether to create a new xwidget-webkit session.
  86 Interactively, URL defaults to the string looking like a url around point."
  87   (interactive (progn
  88                  (require 'browse-url)
  89                  (browse-url-interactive-arg "xwidget-webkit URL: "
  90                                              ;;(xwidget-webkit-current-url)
  91                                              )))
  92   (or (featurep 'xwidget-internal)
  93       (user-error "Your Emacs was not compiled with xwidgets support"))
  94   (when (stringp url)
  95     (if new-session
  96         (xwidget-webkit-new-session url)
  97       (xwidget-webkit-goto-url url))))
  98
  99 ;;todo.
 100 ;; - check that the webkit support is compiled in
 101 (defvar xwidget-webkit-mode-map
 102   (let ((map (make-sparse-keymap)))
 103     (define-key map "g" 'xwidget-webkit-browse-url)
 104     (define-key map "a" 'xwidget-webkit-adjust-size-dispatch)
 105     (define-key map "b" 'xwidget-webkit-back)
 106     (define-key map "r" 'xwidget-webkit-reload)
 107     (define-key map "t" (lambda () (interactive) (message "o"))) ;FIXME: ?!?
 108     (define-key map "\C-m" 'xwidget-webkit-insert-string)
 109     (define-key map "w" 'xwidget-webkit-current-url)
 110
 111     ;;similar to image mode bindings
 112     (define-key map (kbd "SPC")                 'xwidget-webkit-scroll-up)
 113     (define-key map (kbd "DEL")                 'xwidget-webkit-scroll-down)
 114
 115     (define-key map [remap scroll-up]           'xwidget-webkit-scroll-up)
 116     (define-key map [remap scroll-up-command]   'xwidget-webkit-scroll-up)
 117
 118     (define-key map [remap scroll-down]         'xwidget-webkit-scroll-down)
 119     (define-key map [remap scroll-down-command] 'xwidget-webkit-scroll-down)
 120
 121     (define-key map [remap forward-char]        'xwidget-webkit-scroll-forward)
 122     (define-key map [remap backward-char]       'xwidget-webkit-scroll-backward)
 123     (define-key map [remap right-char]          'xwidget-webkit-scroll-forward)
 124     (define-key map [remap left-char]           'xwidget-webkit-scroll-backward)
 125     ;; (define-key map [remap previous-line]          'image-previous-line)
 126     ;; (define-key map [remap next-line]              'image-next-line)
 127
 128     ;; (define-key map [remap move-beginning-of-line] 'image-bol)
 129     ;; (define-key map [remap move-end-of-line]       'image-eol)
 130     ;; (define-key map [remap beginning-of-buffer]    'image-bob)
 131     ;; (define-key map [remap end-of-buffer]          'image-eob)
 132     map)
 133   "Keymap for `xwidget-webkit-mode'.")
 134
 135 (defun xwidget-webkit-scroll-up ()
 136   "Scroll webkit up."
 137   (interactive)
 138   (xwidget-webkit-execute-script
 139    (xwidget-webkit-current-session)
 140    "window.scrollBy(0, 50);"))
 141
 142 (defun xwidget-webkit-scroll-down ()
 143   "Scroll webkit down."
 144   (interactive)
 145   (xwidget-webkit-execute-script
 146    (xwidget-webkit-current-session)
 147    "window.scrollBy(0, -50);"))
 148
 149 (defun xwidget-webkit-scroll-forward ()
 150   "Scroll webkit forwards."
 151   (interactive)
 152   (xwidget-webkit-execute-script
 153    (xwidget-webkit-current-session)
 154    "window.scrollBy(50, 0);"))
 155
 156 (defun xwidget-webkit-scroll-backward ()
 157   "Scroll webkit backwards."
 158   (interactive)
 159   (xwidget-webkit-execute-script
 160    (xwidget-webkit-current-session)
 161    "window.scrollBy(-50, 0);"))
 162
 163
 164 ;; The xwidget event needs to go into a higher level handler
 165 ;; since the xwidget can generate an event even if it's offscreen.
 166 ;; TODO this needs to use callbacks and consider different xwidget event types.
 167 (define-key (current-global-map) [xwidget-event] #'xwidget-event-handler)
 168 (defun xwidget-log (&rest msg)
 169   "Log MSG to a buffer."
 170   (let ((buf (get-buffer-create " *xwidget-log*")))
 171     (with-current-buffer buf
 172       (insert (apply #'format msg))
 173       (insert "\n"))))
 174
 175 (defun xwidget-event-handler ()
 176   "Receive xwidget event."
 177   (interactive)
 178   (xwidget-log "stuff happened to xwidget %S" last-input-event)
 179   (let*
 180       ((xwidget-event-type (nth 1 last-input-event))
 181        (xwidget (nth 2 last-input-event))
 182        ;;(xwidget-callback (xwidget-get xwidget 'callback))
 183        ;;TODO stopped working for some reason
 184        )
 185     ;;(funcall  xwidget-callback xwidget xwidget-event-type)
 186     (message "xw callback %s" xwidget)
 187     (funcall  'xwidget-webkit-callback xwidget xwidget-event-type)))
 188
 189 (defun xwidget-webkit-callback (xwidget xwidget-event-type)
 190   "Callback for xwidgets.
 191 XWIDGET instance, XWIDGET-EVENT-TYPE depends on the originating xwidget."
 192   (if (not (buffer-live-p (xwidget-buffer xwidget)))
 193       (xwidget-log
 194        "error: callback called for xwidget with dead buffer")
 195     (with-current-buffer (xwidget-buffer xwidget)
 196       (cond ((eq xwidget-event-type 'load-changed)
 197              (xwidget-log "webkit finished loading: '%s'"
 198                           (xwidget-webkit-get-title xwidget))
 199              ;;TODO - check the native/internal scroll
 200              ;;(xwidget-adjust-size-to-content xwidget)
 201              (xwidget-webkit-adjust-size-dispatch) ;;TODO xwidget arg
 202              (rename-buffer (format "*xwidget webkit: %s *"
 203                                     (xwidget-webkit-get-title xwidget)))
 204              (pop-to-buffer (current-buffer)))
 205             ((eq xwidget-event-type 'decide-policy)
 206              (let ((strarg  (nth 3 last-input-event)))
 207                (if (string-match ".*#\\(.*\\)" strarg)
 208                    (xwidget-webkit-show-id-or-named-element
 209                     xwidget
 210                     (match-string 1 strarg)))))
 211             ((eq xwidget-event-type 'javascript-callback)
 212              (let ((proc (nth 3 last-input-event))
 213                    (arg  (nth 4 last-input-event)))
 214                (funcall proc arg)))
 215             (t (xwidget-log "unhandled event:%s" xwidget-event-type))))))
 216
 217 (defvar bookmark-make-record-function)
 218 (define-derived-mode xwidget-webkit-mode
 219     special-mode "xwidget-webkit" "Xwidget webkit view mode."
 220     (setq buffer-read-only t)
 221     (setq-local bookmark-make-record-function
 222                 #'xwidget-webkit-bookmark-make-record)
 223     ;; Keep track of [vh]scroll when switching buffers
 224     (image-mode-setup-winprops))
 225
 226 (defun xwidget-webkit-bookmark-make-record ()
 227   "Integrate Emacs bookmarks with the webkit xwidget."
 228   (nconc (bookmark-make-record-default t t)
 229          `((page     . ,(xwidget-webkit-current-url))
 230            (handler  . (lambda (bmk) (browse-url
 231                                  (bookmark-prop-get bmk 'page)))))))
 232
 233
 234 (defvar xwidget-webkit-last-session-buffer nil)
 235
 236 (defun xwidget-webkit-last-session ()
 237   "Last active webkit, or nil."
 238   (if (buffer-live-p xwidget-webkit-last-session-buffer)
 239       (with-current-buffer xwidget-webkit-last-session-buffer
 240         (xwidget-at (point-min)))
 241     nil))
 242
 243 (defun xwidget-webkit-current-session ()
 244   "Either the webkit in the current buffer, or the last one used.
 245 The latter might be nil."
 246   (or (xwidget-at (point-min)) (xwidget-webkit-last-session)))
 247
 248 (defun xwidget-adjust-size-to-content (xw)
 249   "Resize XW to content."
 250   ;; xwidgets doesn't support widgets that have their own opinions about
 251   ;; size well, yet this reads the desired size and resizes the Emacs
 252   ;; allocated area accordingly.
 253   (let ((size (xwidget-size-request xw)))
 254     (xwidget-resize xw (car size) (cadr size))))
 255
 256
 257 (defvar xwidget-webkit-activeelement-js"
 258 function findactiveelement(doc){
 259 //alert(doc.activeElement.value);
 260    if(doc.activeElement.value != undefined){
 261       return doc.activeElement;
 262    }else{
 263         // recurse over the child documents:
 264         var frames = doc.getElementsByTagName('frame');
 265         for (var i = 0; i < frames.length; i++)
 266         {
 267                 var d = frames[i].contentDocument;
 268                  var rv = findactiveelement(d);
 269                  if(rv != undefined){
 270                     return rv;
 271                  }
 272         }
 273     }
 274     return undefined;
 275 };
 276
 277
 278 "
 279
 280   "javascript that finds the active element."
 281   ;; Yes it's ugly, because:
 282   ;; - there is apparently no way to find the active frame other than recursion
 283   ;; - the js "for each" construct misbehaved on the "frames" collection
 284   ;; - a window with no frameset still has frames.length == 1, but
 285   ;; frames[0].document.activeElement != document.activeElement
 286   ;;TODO the activeelement type needs to be examined, for iframe, etc.
 287   )
 288
 289 (defun xwidget-webkit-insert-string (xw str)
 290   "Insert string STR in the active field in the webkit XW."
 291   ;; Read out the string in the field first and provide for edit.
 292   (interactive
 293    (let* ((xww (xwidget-webkit-current-session))
 294
 295           (field-value
 296            (progn
 297              (xwidget-webkit-execute-script xww xwidget-webkit-activeelement-js)
 298              (xwidget-webkit-execute-script-rv
 299               xww
 300               "findactiveelement(document).value;")))
 301           (field-type (xwidget-webkit-execute-script-rv
 302                        xww
 303                        "findactiveelement(document).type;")))
 304      (list xww
 305            (cond ((equal "text" field-type)
 306                   (read-string "Text: " field-value))
 307                  ((equal "password" field-type)
 308                   (read-passwd "Password: " nil field-value))
 309                  ((equal "textarea" field-type)
 310                   (xwidget-webkit-begin-edit-textarea xww field-value))))))
 311   (xwidget-webkit-execute-script
 312    xw
 313    (format "findactiveelement(document).value='%s'" str)))
 314
 315 (defvar xwidget-xwbl)
 316 (defun xwidget-webkit-begin-edit-textarea (xw text)
 317   "Start editing of a webkit text area.
 318 XW is the xwidget identifier, TEXT is retrieved from the webkit."
 319   (switch-to-buffer
 320    (generate-new-buffer "textarea"))
 321   (set (make-local-variable 'xwidget-xwbl) xw)
 322   (insert text))
 323
 324 (defun xwidget-webkit-end-edit-textarea ()
 325   "End editing of a webkit text area."
 326   (interactive)
 327   (goto-char (point-min))
 328   (while (search-forward "\n" nil t)
 329     (replace-match "\\n" nil t))
 330   (xwidget-webkit-execute-script
 331    xwidget-xwbl
 332    (format "findactiveelement(document).value='%s'"
 333            (buffer-substring (point-min) (point-max))))
 334   ;;TODO convert linefeed to \n
 335   )
 336
 337 (defun xwidget-webkit-show-named-element (xw element-name)
 338   "Make webkit xwidget XW show a named element ELEMENT-NAME.
 339 For example, use this to display an anchor."
 340   (interactive (list (xwidget-webkit-current-session)
 341                      (read-string "Element name: ")))
 342   ;;TODO since an xwidget is an Emacs object, it is not trivial to do
 343   ;; some things that are taken for granted in a normal browser.
 344   ;; scrolling an anchor/named-element into view is one such thing.
 345   ;; This function implements a proof-of-concept for this.  Problems
 346   ;; remaining: - The selected window is scrolled but this is not
 347   ;; always correct - This needs to be interfaced into browse-url
 348   ;; somehow.  The tricky part is that we need to do this in two steps:
 349   ;; A: load the base url, wait for load signal to arrive B: navigate
 350   ;; to the anchor when the base url is finished rendering
 351
 352   ;; This part figures out the Y coordinate of the element
 353   (let ((y (string-to-number
 354             (xwidget-webkit-execute-script-rv
 355              xw
 356              (format
 357               "document.getElementsByName('%s')[0].getBoundingClientRect().top"
 358               element-name)
 359              0))))
 360     ;; Now we need to tell Emacs to scroll the element into view.
 361     (xwidget-log "scroll: %d" y)
 362     (set-window-vscroll (selected-window) y t)))
 363
 364 (defun xwidget-webkit-show-id-element (xw element-id)
 365   "Make webkit xwidget XW show an id-element ELEMENT-ID.
 366 For example, use this to display an anchor."
 367   (interactive (list (xwidget-webkit-current-session)
 368                      (read-string "Element id: ")))
 369   (let ((y (string-to-number
 370             (xwidget-webkit-execute-script-rv
 371              xw
 372              (format "document.getElementById('%s').getBoundingClientRect().top"
 373                      element-id)
 374              0))))
 375     ;; Now we need to tell Emacs to scroll the element into view.
 376     (xwidget-log "scroll: %d" y)
 377     (set-window-vscroll (selected-window) y t)))
 378
 379 (defun xwidget-webkit-show-id-or-named-element (xw element-id)
 380    "Make webkit xwidget XW show a name or element id ELEMENT-ID.
 381 For example, use this to display an anchor."
 382   (interactive (list (xwidget-webkit-current-session)
 383                      (read-string "Name or element id: ")))
 384   (let* ((y1 (string-to-number
 385               (xwidget-webkit-execute-script-rv
 386                xw
 387                (format "document.getElementsByName('%s')[0].getBoundingClientRect().top" element-id)
 388                "0")))
 389          (y2 (string-to-number
 390               (xwidget-webkit-execute-script-rv
 391                xw
 392                (format "document.getElementById('%s').getBoundingClientRect().top" element-id)
 393                "0")))
 394          (y3 (max y1 y2)))
 395     ;; Now we need to tell Emacs to scroll the element into view.
 396     (xwidget-log "scroll: %d" y3)
 397     (set-window-vscroll (selected-window) y3 t)))
 398
 399 (defun xwidget-webkit-adjust-size-to-content ()
 400   "Adjust webkit to content size."
 401   (interactive)
 402   (xwidget-adjust-size-to-content (xwidget-webkit-current-session)))
 403
 404 (defun xwidget-webkit-adjust-size-dispatch ()
 405   "Adjust size according to mode."
 406   (interactive)
 407   (xwidget-webkit-adjust-size-to-window)
 408   ;; The recenter is intended to correct a visual glitch.
 409   ;; It errors out if the buffer isn't visible, but then we don't get
 410   ;; the glitch, so silence errors.
 411   (ignore-errors
 412     (recenter-top-bottom)))
 413
 414 (defun xwidget-webkit-adjust-size-to-window ()
 415   "Adjust webkit to window."
 416   (interactive)
 417   (xwidget-resize (xwidget-webkit-current-session) (window-pixel-width)
 418                   (window-pixel-height)))
 419
 420 (defun xwidget-webkit-adjust-size (w h)
 421   "Manually set webkit size to width W, height H."
 422   ;; TODO shouldn't be tied to the webkit xwidget
 423   (interactive "nWidth:\nnHeight:\n")
 424   (xwidget-resize (xwidget-webkit-current-session) w h))
 425
 426 (defun xwidget-webkit-fit-width ()
 427   "Adjust width of webkit to window width."
 428   (interactive)
 429   (xwidget-webkit-adjust-size (- (nth 2 (window-inside-pixel-edges))
 430                                  (car (window-inside-pixel-edges)))
 431                               1000))
 432
 433 (defun xwidget-webkit-new-session (url)
 434   "Create a new webkit session buffer with URL."
 435   (let*
 436       ((bufname (generate-new-buffer-name "*xwidget-webkit*"))
 437        xw)
 438     (setq xwidget-webkit-last-session-buffer (switch-to-buffer
 439                                               (get-buffer-create bufname)))
 440     (insert " 'a' adjusts the xwidget size.")
 441     (setq xw (xwidget-insert 1 'webkit  bufname 1000 1000))
 442     (xwidget-put xw 'callback 'xwidget-webkit-callback)
 443     (xwidget-webkit-mode)
 444     (xwidget-webkit-goto-uri (xwidget-webkit-last-session) url)))
 445
 446
 447 (defun xwidget-webkit-goto-url (url)
 448   "Goto URL."
 449   (if (xwidget-webkit-current-session)
 450       (progn
 451         (xwidget-webkit-goto-uri (xwidget-webkit-current-session) url))
 452     (xwidget-webkit-new-session url)))
 453
 454 (defun xwidget-webkit-back ()
 455   "Go back in history."
 456   (interactive)
 457   (xwidget-webkit-execute-script (xwidget-webkit-current-session)
 458                                  "history.go(-1);"))
 459
 460 (defun xwidget-webkit-reload ()
 461   "Reload current url."
 462   (interactive)
 463   (xwidget-webkit-execute-script (xwidget-webkit-current-session)
 464                                  "history.go(0);"))
 465
 466 (defun xwidget-webkit-current-url ()
 467   "Get the webkit url and place it on the kill-ring."
 468   (interactive)
 469   (let* ((rv (xwidget-webkit-execute-script-rv (xwidget-webkit-current-session)
 470                                                "document.URL"))
 471          (url (kill-new (or rv ""))))
 472     (message "url: %s" url)
 473     url))
 474
 475 (defun xwidget-webkit-execute-script-rv (xw script &optional default)
 476   "Same as `xwidget-webkit-execute-script' but with return value.
 477 XW is the webkit instance.  SCRIPT is the script to execute.
 478 DEFAULT is the default return value."
 479   ;; Notice the ugly "title" hack.  It is needed because the Webkit
 480   ;; API at the time of writing didn't support returning values.  This
 481   ;; is a wrapper for the title hack so it's easy to remove should
 482   ;; Webkit someday support JS return values or we find some other way
 483   ;; to access the DOM.
 484
 485   ;; Reset webkit title.  Not very nice.
 486   (let* ((emptytag "titlecantbewhitespaceohthehorror")
 487          title)
 488     (xwidget-webkit-execute-script xw (format "document.title=\"%s\";"
 489                                               (or default emptytag)))
 490     (xwidget-webkit-execute-script xw (format "document.title=%s;" script))
 491     (setq title (xwidget-webkit-get-title xw))
 492     (if (equal emptytag title)
 493         (setq title ""))
 494     (unless title
 495       (setq title default))
 496     title))
 497
 498 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 499 (defun xwidget-webkit-get-selection ()
 500   "Get the webkit selection."
 501   (xwidget-webkit-execute-script-rv (xwidget-webkit-current-session)
 502                                     "window.getSelection().toString();"))
 503
 504 (defun xwidget-webkit-copy-selection-as-kill ()
 505   "Get the webkit selection and put it on the kill-ring."
 506   (interactive)
 507   (kill-new (xwidget-webkit-get-selection)))
 508
 509
 510 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 511 ;; Xwidget plist management (similar to the process plist functions)
 512
 513 (defun xwidget-get (xwidget propname)
 514   "Get an xwidget's property value.
 515 XWIDGET is an xwidget, PROPNAME a property.
 516 Returns the last value stored with `xwidget-put'."
 517   (plist-get (xwidget-plist xwidget) propname))
 518
 519 (defun xwidget-put (xwidget propname value)
 520   "Set an xwidget's property value.
 521 XWIDGET is an xwidget, PROPNAME a property to be set to specified VALUE.
 522 You can retrieve the value with `xwidget-get'."
 523   (set-xwidget-plist xwidget
 524                      (plist-put (xwidget-plist xwidget) propname value)))
 525
 526
 527 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 528
 529 (defvar xwidget-view-list)              ; xwidget.c
 530 (defvar xwidget-list)                   ; xwidget.c
 531
 532 (defun xwidget-delete-zombies ()
 533   "Helper for `xwidget-cleanup'."
 534   (dolist (xwidget-view xwidget-view-list)
 535     (when (or (not (window-live-p (xwidget-view-window xwidget-view)))
 536               (not (memq (xwidget-view-model xwidget-view)
 537                          xwidget-list)))
 538       (delete-xwidget-view xwidget-view))))
 539
 540 (defun xwidget-cleanup ()
 541   "Delete zombie xwidgets."
 542   ;; During development it was sometimes easy to wind up with zombie
 543   ;; xwidget instances.
 544   ;; This function tries to implement a workaround should it occur again.
 545   (interactive)
 546   ;; Kill xviews that should have been deleted but still linger.
 547   (xwidget-delete-zombies)
 548   ;; Redraw display otherwise ghost of zombies will remain to haunt the screen
 549   (redraw-display))
 550
 551 (defun xwidget-kill-buffer-query-function ()
 552   "Ask before killing a buffer that has xwidgets."
 553   (let ((xwidgets (get-buffer-xwidgets (current-buffer))))
 554     (or (not xwidgets)
 555         (not (memq t (mapcar #'xwidget-query-on-exit-flag xwidgets)))
 556         (yes-or-no-p
 557          (format "Buffer %S has xwidgets; kill it? " (buffer-name))))))
 558
 559 (when (featurep 'xwidget-internal)
 560   (add-hook 'kill-buffer-query-functions #'xwidget-kill-buffer-query-function)
 561   ;; This would have felt better in C, but this seems to work well in
 562   ;; practice though.
 563   (add-hook 'window-configuration-change-hook #'xwidget-delete-zombies))
 564
 565 (provide 'xwidget)
 566 ;;; xwidget.el ends here