X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/0b356a6aeb7c908e778ac20497bc90fee287af66..c430f7e23fc2c22f251ace4254e37dea1452dfc3:/lisp/xwidget.el

diff --git a/lisp/xwidget.el b/lisp/xwidget.el
index 41e2c1cef6..7a0ca8bd55 100644
--- a/lisp/xwidget.el
+++ b/lisp/xwidget.el
@@ -23,9 +23,10 @@
 
 ;;; Commentary:
 ;;
-;; See xwidget.c for more api functions
+;; See xwidget.c for more api functions.
 
-;;TODO this breaks compilation when we dont have xwidgets
+;; This breaks compilation when we don't have xwidgets.
+;; And is pointless when we do, since it's in C and so preloaded.
 ;;(require 'xwidget-internal)
 
 ;;; Code:
@@ -33,36 +34,43 @@
 (require 'cl-lib)
 (require 'bookmark)
 
-(defcustom xwidget-webkit-scroll-behaviour 'native
-  "Scroll behaviour of the webkit instance.
-'native or 'image."
-  :version "25.1"
-  :group 'frames   ; TODO add xwidgets group if more options are added
-  :type '(choice (const native) (const image)))
+(declare-function make-xwidget "xwidget.c"
+                  (type title width height arguments &optional buffer))
+(declare-function xwidget-set-adjustment "xwidget.c"
+                  (xwidget axis relative value))
+(declare-function xwidget-buffer "xwidget.c" (xwidget))
+(declare-function xwidget-webkit-get-title "xwidget.c" (xwidget))
+(declare-function xwidget-size-request "xwidget.c" (xwidget))
+(declare-function xwidget-resize "xwidget.c" (xwidget new-width new-height))
+(declare-function xwidget-webkit-execute-script "xwidget.c" (xwidget script))
+(declare-function xwidget-webkit-goto-uri "xwidget.c" (xwidget uri))
+(declare-function xwidget-plist "xwidget.c" (xwidget))
+(declare-function set-xwidget-plist "xwidget.c" (xwidget plist))
+(declare-function xwidget-view-window "xwidget.c" (xwidget-view))
+(declare-function xwidget-view-model "xwidget.c" (xwidget-view))
+(declare-function delete-xwidget-view "xwidget.c" (xwidget-view))
+(declare-function get-buffer-xwidgets "xwidget.c" (buffer))
+(declare-function xwidget-query-on-exit-flag "xwidget.c" (xwidget))
 
 (defun xwidget-insert (pos type title width height &optional args)
-  "Insert an xwidget at POS.
-given ID, TYPE, TITLE WIDTH and
-HEIGHT in the current buffer.
-
-Return ID
-
-see `make-xwidget' for types suitable for TYPE.
-Optional argument ARGS usage depends on the xwidget."
+  "Insert an xwidget at position POS.
+Supply the xwidget's TYPE, TITLE, WIDTH, and HEIGHT.
+See `make-xwidget' for the possible TYPE values.
+The usage of optional argument ARGS depends on the xwidget.
+This returns the result of `make-xwidget'."
   (goto-char pos)
-  (let ((id (make-xwidget (point) (point)
-                          type title width height args)))
+  (let ((id (make-xwidget type title width height args)))
     (put-text-property (point) (+ 1 (point))
                        'display (list 'xwidget ':xwidget id))
     id))
 
 (defun xwidget-at (pos)
   "Return xwidget at POS."
-  ;;TODO this function is a bit tedious because the C layer isnt well
-  ;;protected yet and xwidgetp aparently doesnt work yet
+  ;; TODO this function is a bit tedious because the C layer isn't well
+  ;; protected yet and xwidgetp apparently doesn't work yet.
   (let* ((disp (get-text-property pos 'display))
          (xw (car (cdr (cdr  disp)))))
-    ;;(if ( xwidgetp  xw) xw nil)
+    ;;(if (xwidgetp  xw) xw nil)
     (if (equal 'xwidget (car disp)) xw)))
 
 
@@ -75,13 +83,15 @@ Optional argument ARGS usage depends on the xwidget."
 ;;;###autoload
 (defun xwidget-webkit-browse-url (url &optional new-session)
   "Ask xwidget-webkit to browse URL.
-NEW-SESSION specifies whether to create a new xwidget-webkit session.  URL
-defaults to the string looking like a url around the cursor position."
+NEW-SESSION specifies whether to create a new xwidget-webkit session.
+Interactively, URL defaults to the string looking like a url around point."
   (interactive (progn
                  (require 'browse-url)
                  (browse-url-interactive-arg "xwidget-webkit URL: "
-                                             ;;( xwidget-webkit-current-url)
+                                             ;;(xwidget-webkit-current-url)
                                              )))
+  (or (featurep 'xwidget-internal)
+      (user-error "Your Emacs was not compiled with xwidgets support"))
   (when (stringp url)
     (if new-session
         (xwidget-webkit-new-session url)
@@ -93,9 +103,9 @@ defaults to the string looking like a url around the cursor position."
   (let ((map (make-sparse-keymap)))
     (define-key map "g" 'xwidget-webkit-browse-url)
     (define-key map "a" 'xwidget-webkit-adjust-size-dispatch)
-    (define-key map "b" 'xwidget-webkit-back )
-    (define-key map "r" 'xwidget-webkit-reload )
-    (define-key map "t" (lambda () (interactive) (message "o")) )
+    (define-key map "b" 'xwidget-webkit-back)
+    (define-key map "r" 'xwidget-webkit-reload)
+    (define-key map "t" (lambda () (interactive) (message "o"))) ;FIXME: ?!?
     (define-key map "\C-m" 'xwidget-webkit-insert-string)
     (define-key map "w" 'xwidget-webkit-current-url)
 
@@ -124,45 +134,35 @@ defaults to the string looking like a url around the cursor position."
   "Keymap for `xwidget-webkit-mode'.")
 
 (defun xwidget-webkit-scroll-up ()
-  "Scroll webkit up,either native or like image mode."
+  "Scroll webkit up."
   (interactive)
-  (if (eq xwidget-webkit-scroll-behaviour 'native)
-      (xwidget-set-adjustment (xwidget-webkit-last-session) 'vertical t 50)
-    (image-scroll-up)))
+  (xwidget-set-adjustment (xwidget-webkit-last-session) 'vertical t 50))
 
 (defun xwidget-webkit-scroll-down ()
-  "Scroll webkit down,either native or like image mode."
+  "Scroll webkit down."
   (interactive)
-  (if (eq xwidget-webkit-scroll-behaviour 'native)
-      (xwidget-set-adjustment (xwidget-webkit-last-session) 'vertical t -50)
-    (image-scroll-down)))
+  (xwidget-set-adjustment (xwidget-webkit-last-session) 'vertical t -50))
 
 (defun xwidget-webkit-scroll-forward ()
-  "Scroll webkit forward,either native or like image mode."
+  "Scroll webkit forwards."
   (interactive)
-  (if (eq xwidget-webkit-scroll-behaviour 'native)
-      (xwidget-set-adjustment (xwidget-webkit-last-session) 'horizontal t 50)
-    (xwidget-webkit-scroll-forward)))
+  (xwidget-set-adjustment (xwidget-webkit-last-session) 'horizontal t 50))
 
 (defun xwidget-webkit-scroll-backward ()
-  "Scroll webkit backward,either native or like image mode."
+  "Scroll webkit backwards."
   (interactive)
-  (if (eq xwidget-webkit-scroll-behaviour 'native)
-      (xwidget-set-adjustment (xwidget-webkit-last-session) 'horizontal t -50)
-    (xwidget-webkit-scroll-backward)))
+  (xwidget-set-adjustment (xwidget-webkit-last-session) 'horizontal t -50))
 
 
-;;the xwidget event needs to go into a higher level handler
-;;since the xwidget can generate an event even if its offscreen
-;;TODO this needs to use callbacks and consider different xw ev types
-(define-key (current-global-map) [xwidget-event] 'xwidget-event-handler)
-(defun xwidget-log ( &rest msg)
+;; The xwidget event needs to go into a higher level handler
+;; since the xwidget can generate an event even if it's offscreen.
+;; TODO this needs to use callbacks and consider different xwidget event types.
+(define-key (current-global-map) [xwidget-event] #'xwidget-event-handler)
+(defun xwidget-log (&rest msg)
   "Log MSG to a buffer."
-  (let ( (buf  (get-buffer-create "*xwidget-log*")))
-    (save-excursion
-      (buffer-disable-undo buf)
-      (set-buffer buf)
-      (insert (apply  'format msg))
+  (let ((buf (get-buffer-create " *xwidget-log*")))
+    (with-current-buffer buf
+      (insert (apply #'format msg))
       (insert "\n"))))
 
 (defun xwidget-event-handler ()
@@ -182,67 +182,64 @@ defaults to the string looking like a url around the cursor position."
 (defun xwidget-webkit-callback (xwidget xwidget-event-type)
   "Callback for xwidgets.
 XWIDGET instance, XWIDGET-EVENT-TYPE depends on the originating xwidget."
-  (save-excursion
-    (cond ((buffer-live-p (xwidget-buffer xwidget))
-           (set-buffer (xwidget-buffer xwidget))
-           (let* ((strarg  (nth 3 last-input-event)))
-             (cond ((eq xwidget-event-type 'document-load-finished)
-                    (xwidget-log "webkit finished loading: '%s'"
-                                 (xwidget-webkit-get-title xwidget))
-                    ;;TODO - check the native/internal scroll
-                    ;;(xwidget-adjust-size-to-content xwidget)
-                    (xwidget-webkit-adjust-size-dispatch) ;;TODO xwidget arg
-                    (rename-buffer (format "*xwidget webkit: %s *"
-                                           (xwidget-webkit-get-title xwidget)))
-                    (pop-to-buffer (current-buffer)))
-                   ((eq xwidget-event-type
-                        'navigation-policy-decision-requested)
-                    (if (string-match ".*#\\(.*\\)" strarg)
-                        (xwidget-webkit-show-id-or-named-element
-                         xwidget
-                         (match-string 1 strarg))))
-                   (t (xwidget-log "unhandled event:%s" xwidget-event-type)))))
-          (t (xwidget-log
-              "error: callback called for xwidget with dead buffer")))))
+  (if (not (buffer-live-p (xwidget-buffer xwidget)))
+      (xwidget-log
+       "error: callback called for xwidget with dead buffer")
+    (with-current-buffer (xwidget-buffer xwidget)
+      (let* ((strarg  (nth 3 last-input-event)))
+        (cond ((eq xwidget-event-type 'document-load-finished)
+               (xwidget-log "webkit finished loading: '%s'"
+                            (xwidget-webkit-get-title xwidget))
+               ;;TODO - check the native/internal scroll
+               ;;(xwidget-adjust-size-to-content xwidget)
+               (xwidget-webkit-adjust-size-dispatch) ;;TODO xwidget arg
+               (rename-buffer (format "*xwidget webkit: %s *"
+                                      (xwidget-webkit-get-title xwidget)))
+               (pop-to-buffer (current-buffer)))
+              ((eq xwidget-event-type
+                   'navigation-policy-decision-requested)
+               (if (string-match ".*#\\(.*\\)" strarg)
+                   (xwidget-webkit-show-id-or-named-element
+                    xwidget
+                    (match-string 1 strarg))))
+              (t (xwidget-log "unhandled event:%s" xwidget-event-type)))))))
 
 (defvar bookmark-make-record-function)
 (define-derived-mode xwidget-webkit-mode
-  special-mode "xwidget-webkit" "xwidget webkit view mode"
-  (setq buffer-read-only t)
-  (setq-local bookmark-make-record-function
-              #'xwidget-webkit-bookmark-make-record)
-  ;; Keep track of [vh]scroll when switching buffers
-  (image-mode-setup-winprops))
+    special-mode "xwidget-webkit" "Xwidget webkit view mode."
+    (setq buffer-read-only t)
+    (setq-local bookmark-make-record-function
+                #'xwidget-webkit-bookmark-make-record)
+    ;; Keep track of [vh]scroll when switching buffers
+    (image-mode-setup-winprops))
 
 (defun xwidget-webkit-bookmark-make-record ()
-"Integrate Emacs bookmarks with the webkit xwidget."
+  "Integrate Emacs bookmarks with the webkit xwidget."
   (nconc (bookmark-make-record-default t t)
          `((page     . ,(xwidget-webkit-current-url))
            (handler  . (lambda (bmk) (browse-url
-                                      (bookmark-prop-get bmk 'page)))))))
+                                 (bookmark-prop-get bmk 'page)))))))
 
 
 (defvar xwidget-webkit-last-session-buffer nil)
 
-(defun  xwidget-webkit-last-session ()
+(defun xwidget-webkit-last-session ()
   "Last active webkit, or nil."
   (if (buffer-live-p xwidget-webkit-last-session-buffer)
       (with-current-buffer xwidget-webkit-last-session-buffer
-        (xwidget-at 1))
+        (xwidget-at (point-min)))
     nil))
 
 (defun xwidget-webkit-current-session ()
-  "Either the webkit in the current buffer, or the last one used,
-which might be nil."
-  (if (xwidget-at 1)
-      (xwidget-at 1)
-    (xwidget-webkit-last-session)))
+  "Either the webkit in the current buffer, or the last one used.
+The latter might be nil."
+  (or (xwidget-at (point-min)) (xwidget-webkit-last-session)))
 
 (defun xwidget-adjust-size-to-content (xw)
   "Resize XW to content."
-  ;;xwidgets doesnt support widgets that have their own opinions about
-  ;;size well yet this reads the desired size and resizes the emacs
-  ;;allocated area accordingly
+  ;; xwidgets doesn't support widgets that have their own opinions about
+  ;; size well, yet this reads the desired size and resizes the Emacs
+  ;; allocated area accordingly.
   (let ((size (xwidget-size-request xw)))
     (xwidget-resize xw (car size) (cadr size))))
 
@@ -271,19 +268,17 @@ function findactiveelement(doc){
 "
 
   "javascript that finds the active element."
-  ;;yes its ugly. because:
-  ;; - there is aparently no way to find the active frame other than recursion
-  ;; - the js "for each" construct missbehaved on the "frames" collection
+  ;; Yes it's ugly, because:
+  ;; - there is apparently no way to find the active frame other than recursion
+  ;; - the js "for each" construct misbehaved on the "frames" collection
   ;; - a window with no frameset still has frames.length == 1, but
   ;; frames[0].document.activeElement != document.activeElement
   ;;TODO the activeelement type needs to be examined, for iframe, etc.
   )
 
 (defun xwidget-webkit-insert-string (xw str)
-  "Insert string in the active field in the webkit.
-Argument XW webkit.
-Argument STR string."
-  ;;read out the string in the field first and provide for edit
+  "Insert string STR in the active field in the webkit XW."
+  ;; Read out the string in the field first and provide for edit.
   (interactive
    (let* ((xww (xwidget-webkit-current-session))
 
@@ -292,15 +287,15 @@ Argument STR string."
              (xwidget-webkit-execute-script xww xwidget-webkit-activeelement-js)
              (xwidget-webkit-execute-script-rv
               xww
-              "findactiveelement(document).value;" )))
+              "findactiveelement(document).value;")))
           (field-type (xwidget-webkit-execute-script-rv
                        xww
-                       "findactiveelement(document).type;" )))
+                       "findactiveelement(document).type;")))
      (list xww
            (cond ((equal "text" field-type)
-                  (read-string "text:" field-value))
+                  (read-string "Text: " field-value))
                  ((equal "password" field-type)
-                  (read-passwd "password:" nil field-value))
+                  (read-passwd "Password: " nil field-value))
                  ((equal "textarea" field-type)
                   (xwidget-webkit-begin-edit-textarea xww field-value))))))
   (xwidget-webkit-execute-script
@@ -313,12 +308,11 @@ Argument STR string."
 XW is the xwidget identifier, TEXT is retrieved from the webkit."
   (switch-to-buffer
    (generate-new-buffer "textarea"))
-
   (set (make-local-variable 'xwidget-xwbl) xw)
   (insert text))
 
 (defun xwidget-webkit-end-edit-textarea ()
-    "End editing of a webkit text area."
+  "End editing of a webkit text area."
   (interactive)
   (goto-char (point-min))
   (while (search-forward "\n" nil t)
@@ -331,18 +325,17 @@ XW is the xwidget identifier, TEXT is retrieved from the webkit."
   )
 
 (defun xwidget-webkit-show-named-element (xw element-name)
-  "Make named-element show.  for instance an anchor.
-Argument XW is the xwidget.
-Argument ELEMENT-NAME is the element name to display in the webkit xwidget."
+  "Make webkit xwidget XW show a named element ELEMENT-NAME.
+For example, use this to display an anchor."
   (interactive (list (xwidget-webkit-current-session)
-                     (read-string "element name:")))
+                     (read-string "Element name: ")))
   ;;TODO since an xwidget is an Emacs object, it is not trivial to do
   ;; some things that are taken for granted in a normal browser.
   ;; scrolling an anchor/named-element into view is one such thing.
   ;; This function implements a proof-of-concept for this.  Problems
   ;; remaining: - The selected window is scrolled but this is not
   ;; always correct - This needs to be interfaced into browse-url
-  ;; somehow. the tricky part is that we need to do this in two steps:
+  ;; somehow.  The tricky part is that we need to do this in two steps:
   ;; A: load the base url, wait for load signal to arrive B: navigate
   ;; to the anchor when the base url is finished rendering
 
@@ -354,32 +347,30 @@ Argument ELEMENT-NAME is the element name to display in the webkit xwidget."
               "document.getElementsByName('%s')[0].getBoundingClientRect().top"
               element-name)
              0))))
-    ;; Now we need to tell emacs to scroll the element into view.
+    ;; Now we need to tell Emacs to scroll the element into view.
     (xwidget-log "scroll: %d" y)
     (set-window-vscroll (selected-window) y t)))
 
 (defun xwidget-webkit-show-id-element (xw element-id)
-  "Make id-element show.  for instance an anchor.
-Argument XW is the webkit xwidget.
-Argument ELEMENT-ID is the id of the element to show."
+  "Make webkit xwidget XW show an id-element ELEMENT-ID.
+For example, use this to display an anchor."
   (interactive (list (xwidget-webkit-current-session)
-                     (read-string "element id:")))
+                     (read-string "Element id: ")))
   (let ((y (string-to-number
             (xwidget-webkit-execute-script-rv
              xw
              (format "document.getElementById('%s').getBoundingClientRect().top"
                      element-id)
              0))))
-    ;; Now we need to tell emacs to scroll the element into view.
+    ;; Now we need to tell Emacs to scroll the element into view.
     (xwidget-log "scroll: %d" y)
     (set-window-vscroll (selected-window) y t)))
 
 (defun xwidget-webkit-show-id-or-named-element (xw element-id)
-  "Make id-element show.  for instance an anchor.
-Argument XW is the webkit xwidget.
-Argument ELEMENT-ID is either a name or an element id."
+   "Make webkit xwidget XW show a name or element id ELEMENT-ID.
+For example, use this to display an anchor."
   (interactive (list (xwidget-webkit-current-session)
-                     (read-string "element id:")))
+                     (read-string "Name or element id: ")))
   (let* ((y1 (string-to-number
               (xwidget-webkit-execute-script-rv
                xw
@@ -389,9 +380,9 @@ Argument ELEMENT-ID is either a name or an element id."
               (xwidget-webkit-execute-script-rv
                xw
                (format "document.getElementById('%s').getBoundingClientRect().top" element-id)
-                                                "0")))
+               "0")))
          (y3 (max y1 y2)))
-    ;; Now we need to tell emacs to scroll the element into view.
+    ;; Now we need to tell Emacs to scroll the element into view.
     (xwidget-log "scroll: %d" y3)
     (set-window-vscroll (selected-window) y3 t)))
 
@@ -403,29 +394,24 @@ Argument ELEMENT-ID is either a name or an element id."
 (defun xwidget-webkit-adjust-size-dispatch ()
   "Adjust size according to mode."
   (interactive)
-  (if (eq xwidget-webkit-scroll-behaviour 'native)
-      (xwidget-webkit-adjust-size-to-window)
-    (xwidget-webkit-adjust-size-to-content))
+  (xwidget-webkit-adjust-size-to-window)
   ;; The recenter is intended to correct a visual glitch.
-  ;; It errors out if the buffer isn't visible, but then we dont get the glitch,
-  ;; so silence errors
+  ;; It errors out if the buffer isn't visible, but then we don't get
+  ;; the glitch, so silence errors.
   (ignore-errors
-    (recenter-top-bottom))
-  )
+    (recenter-top-bottom)))
 
 (defun xwidget-webkit-adjust-size-to-window ()
   "Adjust webkit to window."
   (interactive)
-  (xwidget-resize ( xwidget-webkit-current-session) (window-pixel-width)
+  (xwidget-resize (xwidget-webkit-current-session) (window-pixel-width)
                   (window-pixel-height)))
 
 (defun xwidget-webkit-adjust-size (w h)
-  "Manualy set webkit size.
-Argument W width.
-Argument H height."
+  "Manually set webkit size to width W, height H."
   ;; TODO shouldn't be tied to the webkit xwidget
   (interactive "nWidth:\nnHeight:\n")
-  (xwidget-resize ( xwidget-webkit-current-session) w h))
+  (xwidget-resize (xwidget-webkit-current-session) w h))
 
 (defun xwidget-webkit-fit-width ()
   "Adjust width of webkit to window width."
@@ -442,10 +428,10 @@ Argument H height."
     (setq xwidget-webkit-last-session-buffer (switch-to-buffer
                                               (get-buffer-create bufname)))
     (insert " 'a' adjusts the xwidget size.")
-    (setq xw (xwidget-insert 1 'webkit-osr  bufname 1000 1000))
+    (setq xw (xwidget-insert 1 'webkit  bufname 1000 1000))
     (xwidget-put xw 'callback 'xwidget-webkit-callback)
     (xwidget-webkit-mode)
-    (xwidget-webkit-goto-uri (xwidget-webkit-last-session) url )))
+    (xwidget-webkit-goto-uri (xwidget-webkit-last-session) url)))
 
 
 (defun xwidget-webkit-goto-url (url)
@@ -456,7 +442,7 @@ Argument H height."
     (xwidget-webkit-new-session url)))
 
 (defun xwidget-webkit-back ()
-  "Back in history."
+  "Go back in history."
   (interactive)
   (xwidget-webkit-execute-script (xwidget-webkit-current-session)
                                  "history.go(-1);"))
@@ -468,25 +454,25 @@ Argument H height."
                                  "history.go(0);"))
 
 (defun xwidget-webkit-current-url ()
-  "Get the webkit url.  place it on kill ring."
+  "Get the webkit url and place it on the kill-ring."
   (interactive)
   (let* ((rv (xwidget-webkit-execute-script-rv (xwidget-webkit-current-session)
                                                "document.URL"))
          (url (kill-new (or rv ""))))
-    (message "url: %s" url )
+    (message "url: %s" url)
     url))
 
 (defun xwidget-webkit-execute-script-rv (xw script &optional default)
-  "Same as 'xwidget-webkit-execute-script' but but with return value.
-XW is the webkit instance.  SCRIPT is the script to execut.
-DEFAULT is the defaultreturn value."
+  "Same as `xwidget-webkit-execute-script' but with return value.
+XW is the webkit instance.  SCRIPT is the script to execute.
+DEFAULT is the default return value."
   ;; Notice the ugly "title" hack.  It is needed because the Webkit
   ;; API at the time of writing didn't support returning values.  This
-  ;; is a wrapper for the title hack so its easy to remove should
+  ;; is a wrapper for the title hack so it's easy to remove should
   ;; Webkit someday support JS return values or we find some other way
   ;; to access the DOM.
 
-  ;; Reset webkit title. Not very nice.
+  ;; Reset webkit title.  Not very nice.
   (let* ((emptytag "titlecantbewhitespaceohthehorror")
          title)
     (xwidget-webkit-execute-script xw (format "document.title=\"%s\";"
@@ -499,11 +485,6 @@ DEFAULT is the defaultreturn value."
       (setq title default))
     title))
 
-
-;; Use declare here?
-;; (declare-function xwidget-resize-internal "xwidget.c" )
-;; check-declare-function?
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (defun xwidget-webkit-get-selection ()
   "Get the webkit selection."
@@ -511,28 +492,33 @@ DEFAULT is the defaultreturn value."
                                     "window.getSelection().toString();"))
 
 (defun xwidget-webkit-copy-selection-as-kill ()
-  "Get the webkit selection and put it on the kill ring."
+  "Get the webkit selection and put it on the kill-ring."
   (interactive)
   (kill-new (xwidget-webkit-get-selection)))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Xwidget plist management(similar to the process plist functions)
+;; Xwidget plist management (similar to the process plist functions)
 
 (defun xwidget-get (xwidget propname)
-  "Return the value of XWIDGET' PROPNAME property.
-This is the last value stored with `(xwidget-put XWIDGET PROPNAME VALUE)'."
+  "Get an xwidget's property value.
+XWIDGET is an xwidget, PROPNAME a property.
+Returns the last value stored with `xwidget-put'."
   (plist-get (xwidget-plist xwidget) propname))
 
 (defun xwidget-put (xwidget propname value)
-  "Change XWIDGET' PROPNAME property to VALUE.
-It can be retrieved with `(xwidget-get XWIDGET PROPNAME)'."
+  "Set an xwidget's property value.
+XWIDGET is an xwidget, PROPNAME a property to be set to specified VALUE.
+You can retrieve the value with `xwidget-get'."
   (set-xwidget-plist xwidget
                      (plist-put (xwidget-plist xwidget) propname value)))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+(defvar xwidget-view-list)              ; xwidget.c
+(defvar xwidget-list)                   ; xwidget.c
+
 (defun xwidget-delete-zombies ()
   "Helper for `xwidget-cleanup'."
   (dolist (xwidget-view xwidget-view-list)
@@ -547,28 +533,24 @@ It can be retrieved with `(xwidget-get XWIDGET PROPNAME)'."
   ;; xwidget instances.
   ;; This function tries to implement a workaround should it occur again.
   (interactive)
-  ;; Kill xviews who should have been deleted but stull linger.
+  ;; Kill xviews that should have been deleted but still linger.
   (xwidget-delete-zombies)
   ;; Redraw display otherwise ghost of zombies will remain to haunt the screen
   (redraw-display))
 
-;; This would have felt better in C, but this seems to work well in
-;; practice though.
-(if (featurep 'xwidget-internal)
-    (add-hook 'window-configuration-change-hook 'xwidget-delete-zombies))
-
 (defun xwidget-kill-buffer-query-function ()
-  "Ask beforek illing a buffer that has xwidgets."
+  "Ask before killing a buffer that has xwidgets."
   (let ((xwidgets (get-buffer-xwidgets (current-buffer))))
     (or (not xwidgets)
-        (not (memq t (mapcar 'xwidget-query-on-exit-flag xwidgets)))
+        (not (memq t (mapcar #'xwidget-query-on-exit-flag xwidgets)))
         (yes-or-no-p
-         (format "Buffer %S has xwidgets; kill it? "
-                 (buffer-name (current-buffer)))))))
+         (format "Buffer %S has xwidgets; kill it? " (buffer-name))))))
 
-(if (featurep 'xwidget-internal)
-    (add-hook 'kill-buffer-query-functions 'xwidget-kill-buffer-query-function))
+(when (featurep 'xwidget-internal)
+  (add-hook 'kill-buffer-query-functions #'xwidget-kill-buffer-query-function)
+  ;; This would have felt better in C, but this seems to work well in
+  ;; practice though.
+  (add-hook 'window-configuration-change-hook #'xwidget-delete-zombies))
 
 (provide 'xwidget)
-
 ;;; xwidget.el ends here