Doc fixes.

(strokes-mode): Defcustom deleted; replaced by minor mode def with
re-written function.
(strokes-while-inhibiting-garbage-collector): Comment out.
(define-stroke, strokes-fix-button2-command, strokes-insinuated)
(strokes-insinuate, global-set-stroke, describe-stroke)
(load-user-strokes, save-strokes, strokes-bug-address)
(strokes-click-command): Deleted.
(strokes-execute-stroke): Remove strokes-click-p case.
(strokes-describe-stroke): Remove strokes-click-p stuff.
(strokes-help): Fix.
(strokes-report-bug): Alias to report-emacs-bug.
(strokes-prompt-user-save-strokes): Modify format of the file.
(strokes-mode-map, strokes-unload-hook): New.
(strokes-buffer-name): Don't customize.

1 files changed, 184 insertions, 399 deletions

diff --git a/lisp/strokes.el b/lisp/strokes.el
index 2556dbe6b63..3f5a5bb3a75 100644
--- a/lisp/strokes.el
+++ b/lisp/strokes.el
@@ -32,20 +32,22 @@
 ;; > M-x strokes-help
 
 ;; and you can learn how to use the package.  A mouse stroke, for now,
-;; can be defined as holding the middle button, for instance, and then
-;; moving the mouse in whatever pattern you wish, which you have set
-;; Emacs to understand as mapping to a given command.  For example, you
-;; may wish the have a mouse stroke that looks like a capital `C' which
-;; means `copy-region-as-kill'.  Treat strokes just like you do key
-;; bindings.  For example, Emacs sets key bindings globally with the
-;; `global-set-key' command.  Likewise, you can do
+;; can be defined as holding the shift key and the middle button, for
+;; instance, and then moving the mouse in whatever pattern you wish,
+;; which you have set Emacs to understand as mapping to a given
+;; command.  For example, you may wish the have a mouse stroke that
+;; looks like a capital `C' which means `copy-region-as-kill'.  Treat
+;; strokes just like you do key bindings.  For example, Emacs sets key
+;; bindings globally with the `global-set-key' command.  Likewise, you
+;; can do
 
-;; > M-x global-set-stroke
+;; > M-x strokes-global-set-stroke
 
 ;; to interactively program in a stroke.  It would be wise to set the
 ;; first one to this very command, so that from then on, you invoke
-;; `global-set-stroke' with a stroke.  likewise, there may eventually
-;; be a `local-set-stroke' command, also analogous to `local-set-key'.
+;; `strokes-global-set-stroke' with a stroke.  Likewise, there may
+;; eventually be a `strokes-local-set-stroke' command, also analogous
+;; to `local-set-key'.
 
 ;; You can always unset the last stroke definition with the command
 
@@ -58,19 +60,19 @@
 
 ;;    1) To describe a stroke binding, you can type
 
-;;       > M-x describe-stroke
+;;       > M-x strokes-describe-stroke
 
 ;;       analogous to `describe-key'.  It's also wise to have a stroke,
 ;;       like an `h', for help, or a `?', mapped to `describe-stroke'.
 
 ;;    2) stroke bindings are set internally through the Lisp function
-;;       `define-stroke', similar to the `define-key' function.  some
-;;       examples for a 3x3 stroke grid would be
+;;       `strokes-define-stroke', similar to the `define-key' function.
+;;       some examples for a 3x3 stroke grid would be
 
-;;       (define-stroke c-mode-stroke-map
+;;       (strokes-define-stroke c-mode-stroke-map
 ;;                      '((0 . 0) (1 . 1) (2 . 2))
 ;;                      'kill-region)
-;;       (define-stroke strokes-global-map
+;;       (strokes-define-stroke strokes-global-map
 ;;                      '((0 . 0) (0 . 1) (0 . 2) (1 . 2) (2 . 2))
 ;;                      'list-buffers)
 
@@ -107,7 +109,7 @@
 ;; computers as well as people who don't want to see their strokes.
 
 ;; If you find that your mouse is accelerating too fast, you can
-;; execute the UNIX X command to slow it down.  A good possibility is
+;; execute an X command to slow it down.  A good possibility is
 
 ;; % xset m 5/4 8
 
@@ -116,7 +118,7 @@
 ;; Whenever you load in the strokes package, you will be able to save
 ;; what you've done upon exiting Emacs.  You can also do
 
-;; > M-x save-strokes
+;; > M-x strokes-prompt-user-save-strokes
 
 ;; and it will save your strokes in ~/.strokes, or you may wish to change
 ;; this by setting the variable `strokes-file'.
@@ -124,33 +126,20 @@
 ;; Note that internally, all of the routines that are part of this
 ;; package are able to deal with complex strokes, as they are a superset
 ;; of simple strokes.  However, the default of this package will map
-;; mouse button2 to the command `strokes-do-stroke', and NOT
-;; `strokes-do-complex-stroke'.  If you wish to use complex strokes, you
-;; will have to override this key mapping.  Complex strokes are terminated
-;; with mouse button3.  The strokes package will not interfere with
-;; `mouse-yank', but you may want to examine how this is done (see the
-;; variable `strokes-click-command')
+;; S-mouse-2 to the command `strokes-do-stroke', and M-mouse-2 to
+;; `strokes-do-complex-stroke'.  Complex strokes are terminated
+;; with mouse button 3.
 
-;; To get strokes to work as part of your your setup, then you'll have
-;; put the strokes package in your load-path (preferably byte-compiled)
-;; and then add the following to your .emacs file (or wherever
-;; you put Emacs-specific startup preferences):
-
-;;(and window-system
-;;     (require 'strokes))
-
-;; Once loaded, you can start stroking.  You can also toggle between
-;; strokes mode by simple typing
+;; You can also toggle between strokes mode by simple typing
 
 ;; > M-x strokes-mode
 
-;; I am now in the process of porting this package to Emacs.  I also hope
-;; that, with the help of others, this package will be useful in entering
-;; in pictographic-like language text using the mouse (i.e. Korean).
-;; Japanese and Chinese are a bit trickier, but I'm sure that with help
-;; it can be done.  The next version will allow the user to enter strokes
-;; which "remove the pencil from the paper" so to speak, so one character
-;; can have multiple strokes.
+;; I hope that, with the help of others, this package will be useful
+;; in entering in pictographic-like language text using the mouse
+;; (i.e. Korean).  Japanese and Chinese are a bit trickier, but I'm
+;; sure that with help it can be done.  The next version will allow
+;; the user to enter strokes which "remove the pencil from the paper"
+;; so to speak, so one character can have multiple strokes.
 
 ;; You can read more about strokes at:
 
@@ -172,7 +161,7 @@
 ;; macros at (near) max speed.
 
 ;; Tasks: (what I'm getting ready for future version)...
-;; 2) use 'strokes-read-complex-stroke for korean, etc.
+;; 2) use 'strokes-read-complex-stroke for Korean, etc.
 ;; 4) buffer-local 'strokes-local-map, and mode-stroke-maps would be nice
 ;; 6) add some hooks, like `strokes-read-stroke-hook'
 ;; 7) See what people think of the factory settings.  Should I change
@@ -193,10 +182,6 @@
 
 ;;; Constants...
 
-(defconst strokes-version "2.4-Emacs")
-
-(defconst strokes-bug-address "cadet@alum.mit.edu")
-
 (defconst strokes-lift :strokes-lift
   "Symbol representing a stroke lift event for complex strokes.
 Complex strokes are those which contain two or more simple strokes.")
@@ -216,17 +201,18 @@ static char * stroke_xpm[] = {
 \"P     c #FFFF0000FFFF\",
 \".     c #45458B8B0000\",
 /* pixels */\n"
-  "The header to all xpm buffers created by strokes")
+  "The header to all xpm buffers created by strokes.")
 
 ;;; user variables...
 
 (defgroup strokes nil
   "Control Emacs through mouse strokes"
+  :link '(emacs-commentary-link "strokes")
   :link '(url-link "http://www.mit.edu/people/cadet/strokes-help.html")
   :group 'mouse)
 
 (defcustom strokes-modeline-string " Strokes"
-  "*Modeline identification when strokes-mode is on \(default is \" Strokes\"\)."
+  "*Modeline identification when Strokes mode is on \(default is \" Strokes\"\)."
   :type 'string
   :group 'strokes)
 
@@ -245,7 +231,7 @@ the value of `strokes-grid-resolution', since a higher grid resolution
 will correspond to more sample points, and thus more distance
 measurements.  Usually, this is not a problem since you first set
 `strokes-grid-resolution' based on what your computer seems to be able
-to handle (though the defaults are usually more than sufficent), and
+to handle (though the defaults are usually more than sufficient), and
 then you can set `strokes-minimum-match-score' to something that works
 for you.  The only purpose of this variable is to insure that if you
 do a bogus stroke that really doesn't match any of the predefined
@@ -275,10 +261,8 @@ WARNING: Changing the value of this variable will gravely affect the
   :type 'file
   :group 'strokes)
 
-(defcustom strokes-buffer-name " *strokes*"
-  "The buffer that the strokes take place in (default is ` *strokes*')."
-  :type 'string
-  :group 'strokes)
+(defvar strokes-buffer-name " *strokes*"
+  "The name of the buffer that the strokes take place in.")
 
 (defcustom strokes-use-strokes-buffer t
   "*If non-nil, the strokes buffer is used and strokes are displayed.
@@ -288,29 +272,8 @@ the delay in switching to the strokes buffer."
   :type 'boolean
   :group 'strokes)
 
-(defcustom strokes-click-command 'mouse-yank-at-click
-  "*Command to execute when stroke is actually a `click' event.
-This is set to `mouse-yank-at-click' by default."
-  :type 'function
-  :group 'strokes)
-
 ;;; internal variables...
 
-;; This is an internal variable, but we defcustom it so Customize can
-;; use it.
-;;;###autoload
-(defcustom strokes-mode nil
-  "Non-nil when `strokes' is globally enabled.
-Setting this variable directly does not take effect.  Use either Customize
-or M-x strokes-mode."
-  :type 'boolean
-  :set (lambda (symbol value)
-         (strokes-mode (or value 0)))
-  :initialize 'custom-initialize-default
-  :require 'strokes
-  :version "21.1"
-  :group 'strokes)
-
 (defvar strokes-window-configuration nil
   "The special window configuration used when entering strokes.
 This is set properly in the function `strokes-update-window-configuration'.")
@@ -345,10 +308,11 @@ corresponding interactive function")
 
 ;;; Macros...
 
-(defmacro strokes-while-inhibiting-garbage-collector (&rest forms)
-  "Execute FORMS without interference from the garbage collector."
-  `(let ((gc-cons-threshold 134217727))
-     ,@forms))
+;; unused
+;; (defmacro strokes-while-inhibiting-garbage-collector (&rest forms)
+;;   "Execute FORMS without interference from the garbage collector."
+;;   `(let ((gc-cons-threshold 134217727))
+;;      ,@forms))
 
 (defsubst strokes-click-p (stroke)
   "Non-nil if STROKE is really click."
@@ -372,14 +336,12 @@ corresponding interactive function")
 (defmacro strokes-define-stroke (stroke-map stroke def)
   "Add STROKE to STROKE-MAP alist with given command DEF."
   `(if (strokes-click-p ,stroke)
-       (error "That's a click, not a stroke; see `strokes-click-command'")
+       (error "That's a click, not a stroke")
      (setq ,stroke-map (cons (cons ,stroke ,def)
                              (strokes-remassoc ,stroke ,stroke-map)))))
 
-(defalias 'define-stroke 'strokes-define-stroke)
-
 (defsubst strokes-square (x)
-  "Returns the square of the number X"
+  "Return the square of the number X."
   (* x x))
 
 (defsubst strokes-distance-squared (p1 p2)
@@ -392,105 +354,6 @@ P1 and P2 are cons cells in the form (X . Y)."
     (+ (strokes-square (- x2 x1))
        (strokes-square (- y2 y1)))))
 
-;;; Advice for various functions...
-
-;; I'd originally wanted to write a macro that would just take in the
-;; generic functions which use mouse button2 in various modes.  Most of
-;; them are identical in form: they take an event as the single argument
-;; and then do their thing.  I tried writing a macro that looked
-;; something like this, but failed.  Advice just ain't that easy.  The
-;; one that bugged me the most was `Manual-follow-xref', because that had
-;; &rest arguments, and I didn't know how to work around it in defadvice.
-;; However, I was able to fix up most of the important modes (i.e. the
-;; ones I use all the time).  One `bug' in the program that I just can't
-;; seem to figure out is why I can only advise other button2 functions
-;; successfully when the variable `strokes-use-strokes-buffer' is nil.  I
-;; did all the save-excursion/save-window-excursion stuff SPECIFICALLY so
-;; that using the strokes buffer or not would absolutely not affect any
-;; other part of the program.  If someone can figure out how to make the
-;; following advices work w/ regardless of that variable
-;; `strokes-use-strokes-buffer', then that would be a great victory.  If
-;; someone out there would be kind enough to make the commented code
-;; below work, I'd be grateful.  By the way, I put the `protect' keywords
-;; there to insure that if a stroke went bad, then
-;; `strokes-click-command' would be set back.  If this isn't necessary,
-;; then feel free to let me know.
-
-;; For what follows, I really wanted something that would work like this:
-
-;;(strokes-fix-button2 'vm-mouse-button-2)
-
-;; Or even better, I could have simply done something like:
-
-;;(mapcar 'strokes-fix-button2
-;;        '(vm-mouse-button-2
-;;          rmail-summary-mouse-goto-msg
-;;          <rest of them>))
-
-;;; With help from Hans (author of advice.el)...
-(defmacro strokes-fix-button2-command (command)
-  "Fix COMMAND so that it can also work with strokes.
-COMMAND must take one event argument.
-Example of how one might fix up a command that's bound to button2
-and which is an interactive funcion of one event argument:
-
-\(strokes-fix-button2-command 'rmail-summary-mouse-goto-msg)"
-  (let ((command (eval command)))
-    `(progn
-       (defadvice ,command (around strokes-fix-button2 compile preactivate)
-         ,(format "Fix %s to work with strokes." command)
-         (let ((strokes-click-command
-                  ',(intern (format "ad-Orig-%s" command))))
-             (strokes-do-stroke (ad-get-arg 0)))))))
-
-(defvar strokes-insinuated nil)
-
-(defun strokes-insinuate ()
-  "Insinuate Emacs with strokes advices."
-  (unless strokes-insinuated
-    (strokes-fix-button2-command 'vm-mouse-button-2)
-    (strokes-fix-button2-command 'rmail-summary-mouse-goto-msg)
-    (strokes-fix-button2-command 'Buffer-menu-mouse-select)
-    (strokes-fix-button2-command 'w3-widget-button-click)
-    (strokes-fix-button2-command 'widget-image-button-press)
-    (strokes-fix-button2-command 'Info-follow-clicked-node)
-    (strokes-fix-button2-command 'compile-mouse-goto-error)
-    (strokes-fix-button2-command 'gdbsrc-select-or-yank)
-    (strokes-fix-button2-command 'hypropos-mouse-get-doc)
-    (strokes-fix-button2-command 'gnus-mouse-pick-group)
-    (strokes-fix-button2-command 'gnus-mouse-pick-article)
-    (strokes-fix-button2-command 'gnus-article-push-button)
-    (strokes-fix-button2-command 'dired-mouse-find-file)
-    (strokes-fix-button2-command 'url-dired-find-file-mouse)
-    (strokes-fix-button2-command 'dired-u-r-mouse-toggle)
-    (strokes-fix-button2-command 'dired-u-w-mouse-toggle)
-    (strokes-fix-button2-command 'dired-u-x-mouse-toggle)
-    (strokes-fix-button2-command 'dired-g-r-mouse-toggle)
-    (strokes-fix-button2-command 'dired-g-w-mouse-toggle)
-    (strokes-fix-button2-command 'dired-g-x-mouse-toggle)
-    (strokes-fix-button2-command 'dired-o-r-mouse-toggle)
-    (strokes-fix-button2-command 'dired-o-w-mouse-toggle)
-    (strokes-fix-button2-command 'isearch-yank-x-selection)
-    (strokes-fix-button2-command 'occur-mode-mouse-goto)
-    (strokes-fix-button2-command 'cvs-mouse-find-file)
-    (setq strokes-insinuated t)))
-
-;;; I can fix the customize widget button click, but then
-;;; people will get confused when they try to customize
-;;; strokes with the mouse and customize tells them that
-;;; `strokes-click-command' is mapped to `ad-Orig-widget-button-click'
-;;(strokes-fix-button2-command 'widget-button-click)
-
-;;; without the advice, each advised function would look like...
-;;(defadvice vm-mouse-button-2 (around vm-strokes activate protect)
-;;  "Allow strokes to work in VM."
-;;  (if strokes-use-strokes-buffer
-;;      ;; then strokes is no good and we'll have to use the original
-;;      ad-do-it
-;;    ;; otherwise, we can make strokes work too...
-;;    (let ((strokes-click-command 'ad-Orig-vm-mouse-button-2))
-;;      (strokes-do-stroke (ad-get-arg 0)))))
-
 ;;; Functions...
 
 (defsubst strokes-mouse-event-p (event)
@@ -526,7 +389,7 @@ If LINE is nil, return the last position visible in WINDOW."
 (defun strokes-event-closest-point (event &optional start-window)
   "Return the nearest position to where EVENT ended its motion.
 This is computed for the window where EVENT's motion started,
-or for window WINDOW if that is specified."
+or for window START-WINDOW if that is specified."
   (or start-window (setq start-window (posn-window (event-start event))))
   (if (eq start-window (posn-window (event-end event)))
       (if (eq (posn-point (event-end event)) 'vertical-line)
@@ -557,7 +420,7 @@ or for window WINDOW if that is specified."
   (interactive)
   (let ((command (cdar strokes-global-map)))
     (if (y-or-n-p
-         (format "really delete last stroke definition, defined to `%s'? "
+         (format "Really delete last stroke definition, defined to `%s'? "
                  command))
         (progn
           (setq strokes-global-map (cdr strokes-global-map))
@@ -575,13 +438,10 @@ documentation for the `strokes-define-stroke' function."
    (list
     (and (or strokes-mode (strokes-mode t))
          (strokes-read-complex-stroke
-          "Define a new stroke.  Draw with button1 (or 2).  End with button3..."))
-    (read-command "command to map stroke to: ")))
+          "Draw with mouse button 1 (or 2).  End with button 3..."))
+    (read-command "Command to map stroke to: ")))
   (strokes-define-stroke strokes-global-map stroke command))
 
-;;;###autoload
-(defalias 'global-set-stroke 'strokes-global-set-stroke)
-
 ;;(defun global-unset-stroke (stroke); FINISH THIS DEFUN!
 ;;  "delete all strokes matching STROKE from `strokes-global-map',
 ;; letting the user input
@@ -592,11 +452,12 @@ documentation for the `strokes-define-stroke' function."
 ;;  (strokes-define-stroke 'strokes-global-map stroke command))
 
 (defun strokes-get-grid-position (stroke-extent position &optional grid-resolution)
-  "Map POSITION to a new grid position based on its STROKE-EXTENT and GRID-RESOLUTION.
+  "Map POSITION to a new grid position.
+Do so  based on its STROKE-EXTENT and GRID-RESOLUTION.
 STROKE-EXTENT as a list \(\(XMIN . YMIN\) \(XMAX . YMAX\)\).
 If POSITION is a `strokes-lift', then it is itself returned.
 Optional GRID-RESOLUTION may be used in place of STROKES-GRID-RESOLUTION.
-The grid is a square whose dimesion is [0,GRID-RESOLUTION)."
+The grid is a square whose dimension is [0,GRID-RESOLUTION)."
   (cond ((consp position)               ; actual pixel location
          (let ((grid-resolution (or grid-resolution strokes-grid-resolution))
                (x (car position))
@@ -617,7 +478,7 @@ The grid is a square whose dimesion is [0,GRID-RESOLUTION)."
          strokes-lift)))
 
 (defun strokes-get-stroke-extent (pixel-positions)
-  "From a list of absolute PIXEL-POSITIONS, returns absolute spatial extent.
+  "From a list of absolute PIXEL-POSITIONS, return absolute spatial extent.
 The return value is a list ((XMIN . YMIN) (XMAX . YMAX))."
   (if pixel-positions
       (let ((xmin (caar pixel-positions))
@@ -658,7 +519,7 @@ The return value is a list ((XMIN . YMIN) (XMAX . YMAX))."
     nil))
 
 (defun strokes-eliminate-consecutive-redundancies (entries)
-  "Returns a list with no consecutive redundant entries."
+  "Return a list with no consecutive redundant entries."
   ;; defun a grande vitesse grace a Dave G.
   (loop for element on entries
         if (not (equal (car element) (cadr element)))
@@ -686,7 +547,7 @@ The return value is a list ((XMIN . YMIN) (XMAX . YMAX))."
   "Map POSITIONS to a new grid whose dimensions are based on GRID-RESOLUTION.
 POSITIONS is a list of positions and stroke-lifts.
 Optional GRID-RESOLUTION may be used in place of STROKES-GRID-RESOLUTION.
-The grid is a square whose dimesion is [0,GRID-RESOLUTION)."
+The grid is a square whose dimension is [0,GRID-RESOLUTION)."
   (or grid-resolution (setq grid-resolution strokes-grid-resolution))
   (let ((stroke-extent (strokes-get-stroke-extent positions)))
     (mapcar (function
@@ -728,7 +589,7 @@ NOTE: This is where the global variable `strokes-last-stroke' is set."
                                               delta-x)))))
                         (cond ((not both-are-points-p)
                                (list current))
-                              ((null slope) ; undefinded vertical slope
+                              ((null slope) ; undefined vertical slope
                                (if (>= delta-y 0)
                                    (loop for y from y1 below y2
                                          collect (cons x1 y))
@@ -766,7 +627,7 @@ NOTE: This is where the global variable `strokes-last-stroke' is set."
                                                      y))))))))))
 
 (defun strokes-rate-stroke (stroke1 stroke2)
-  "Rates STROKE1 with STROKE2 and returns a score based on a distance metric.
+  "Rates STROKE1 with STROKE2 and return a score based on a distance metric.
 Note: the rating is an error rating, and therefore, a return of 0
 represents a perfect match.  Also note that the order of stroke
 arguments is order-independent for the algorithm used here."
@@ -820,7 +681,7 @@ arguments is order-independent for the algorithm used here."
     nil))
 
 (defun strokes-match-stroke (stroke stroke-map)
-  "Finds the best matching command of STROKE in STROKE-MAP.
+  "Find the best matching command of STROKE in STROKE-MAP.
 Returns the corresponding match as (COMMAND . SCORE)."
   (if (and stroke stroke-map)
       (let ((score (strokes-rate-stroke stroke (caar stroke-map)))
@@ -871,7 +732,8 @@ Optional EVENT is acceptable as the starting event of the stroke"
                               ;; we can draw that point
                               (progn
                                 (goto-char point)
-                                (subst-char-in-region point (1+ point) ?\  strokes-character))
+                                (subst-char-in-region point (1+ point)
+                                                      ?\  strokes-character))
                             ;; otherwise, we can start drawing the next time...
                             (setq safe-to-draw-p t))
                           (push (cdr (mouse-pixel-position))
@@ -880,7 +742,8 @@ Optional EVENT is acceptable as the starting event of the stroke"
             ;; protected
             ;; clean up strokes buffer and then bury it.
             (when (equal (buffer-name) strokes-buffer-name)
-              (subst-char-in-region (point-min) (point-max) strokes-character ?\ )
+              (subst-char-in-region (point-min) (point-max)
+                                    strokes-character ?\ )
               (goto-char (point-min))
               (bury-buffer))))
       ;; Otherwise, don't use strokes buffer and read stroke silently
@@ -897,15 +760,16 @@ Optional EVENT is acceptable as the starting event of the stroke"
                     pix-locs))
           (setq event (read-event))))
       (setq grid-locs (strokes-renormalize-to-grid (nreverse pix-locs)))
-      (strokes-fill-stroke (strokes-eliminate-consecutive-redundancies grid-locs)))))
+      (strokes-fill-stroke
+       (strokes-eliminate-consecutive-redundancies grid-locs)))))
 
 ;;;###autoload
 (defun strokes-read-complex-stroke (&optional prompt event)
   "Read a complex stroke (interactively) and return the stroke.
 Optional PROMPT in minibuffer displays before and during stroke reading.
 Note that a complex stroke allows the user to pen-up and pen-down.  This
-is implemented by allowing the user to paint with button1 or button2 and
-then complete the stroke with button3.
+is implemented by allowing the user to paint with button 1 or button 2 and
+then complete the stroke with button 3.
 Optional EVENT is acceptable as the starting event of the stroke"
   (save-excursion
     (save-window-excursion
@@ -928,7 +792,8 @@ Optional EVENT is acceptable as the starting event of the stroke"
                       (let ((point (strokes-event-closest-point event)))
                         (when point
                           (goto-char point)
-                          (subst-char-in-region point (1+ point) ?\ strokes-character))
+                          (subst-char-in-region point (1+ point)
+                                                ?\ strokes-character))
                         (push (cdr (mouse-pixel-position))
                               pix-locs)))
                   (setq event (read-event)))
@@ -945,7 +810,8 @@ Optional EVENT is acceptable as the starting event of the stroke"
                (strokes-eliminate-consecutive-redundancies grid-locs)))
           ;; protected
           (when (equal (buffer-name) strokes-buffer-name)
-            (subst-char-in-region (point-min) (point-max) strokes-character ?\ )
+            (subst-char-in-region (point-min) (point-max)
+                                  strokes-character ?\ )
             (goto-char (point-min))
             (bury-buffer)))))))
 
@@ -957,19 +823,7 @@ If no stroke matches, nothing is done and return value is nil."
   (let* ((match (strokes-match-stroke stroke strokes-global-map))
          (command (car match))
          (score (cdr match)))
-    (cond ((strokes-click-p stroke)
-           ;; This is the case of a `click' type event.
-           ;; The `sit-for' is a minor frob that has to do with timing
-           ;; problems.  Without the `sit-for', mouse-yank will not
-           ;; yank at the proper location if the user opted for
-           ;; mouse-yank-at-point to be nil (i.e. mouse-yank takes
-           ;; place at pointer position).  The sit-for tells redisplay
-           ;; to be sure to wait for the `*strokes*' buffer to vanish
-           ;; from consideration when deciding on a point to be used
-           ;; for mouse-yank.
-           (sit-for 0)
-           (command-execute strokes-click-command))
-          ((and match (<= score strokes-minimum-match-score))
+    (cond ((and match (<= score strokes-minimum-match-score))
            (message "%s" command)
            (command-execute command))
           ((null strokes-global-map)
@@ -978,7 +832,7 @@ If no stroke matches, nothing is done and return value is nil."
                      (format "No strokes loaded.  Load `%s'? "
                              strokes-file))
                     (strokes-load-user-strokes))
-             (error "No strokes defined; use `global-set-stroke'")))
+             (error "No strokes defined; use `strokes-global-set-stroke'")))
           (t
            (error
             "No stroke matches; see variable `strokes-minimum-match-score'")
@@ -1006,38 +860,23 @@ This must be bound to a mouse event."
   (interactive
    (list
     (strokes-read-complex-stroke
-     "Enter stroke to describe; end with button3...")))
+     "Enter stroke to describe; end with button 3...")))
   (let* ((match (strokes-match-stroke stroke strokes-global-map))
-         (command (or (and (strokes-click-p stroke)
-                           strokes-click-command)
-                      (car match)))
+         (command (car match))
          (score (cdr match)))
-    (if (or (and match
-                 (<= score strokes-minimum-match-score))
-            (and (strokes-click-p stroke)
-                 strokes-click-command))
+    (if (and match
+             (<= score strokes-minimum-match-score))
         (message "That stroke maps to `%s'" command)
       (message "That stroke is undefined"))
     (sleep-for 1)))                     ; helpful for recursive edits
 
 ;;;###autoload
-(defalias 'describe-stroke 'strokes-describe-stroke)
-
-;;;###autoload
 (defun strokes-help ()
-  "Get instructional help on using the `strokes' package."
+  "Get instruction on using the `strokes' package."
   (interactive)
-  (let ((helpdoc
-         "This is help for the strokes package.
-
-If you find something wrong with strokes, or feel that it can be
-improved in some way, then please feel free to email me:
-
-David Bakhash <cadet@mit.edu>
-
-or just do
-
-M-x strokes-report-bug
+  (with-output-to-temp-buffer "*Help with Strokes*"
+    (princ
+     "This is help for the strokes package.
 
 ------------------------------------------------------------
 
@@ -1051,7 +890,7 @@ right every time.
 
 Strokes also allows you to compose documents graphically.  You can
 fully edit documents in Chinese, Japanese, etc. based on Emacs
-strokes.  Once you've done so, you can ascii compress-and-encode them
+strokes.  Once you've done so, you can ASCII compress-and-encode them
 and then safely save them for later use, send letters to friends
 \(using Emacs, of course).  Strokes will later decode these documents,
 extracting the strokes for editing use once again, so the editing
@@ -1072,16 +911,16 @@ To toggle strokes-mode, you just do
 
 When you're ready to start defining strokes, just use the command
 
-> M-x global-set-stroke
+> M-x strokes-global-set-stroke
 
 You will see a ` *strokes*' buffer which is waiting for you to enter in
-your stroke.  When you enter in the stroke, you draw with button1 or
-button2, and then end with button3.  Next, you enter in the command
+your stroke.  When you enter in the stroke, you draw with button 1 or
+button 2, and then end with button 3.  Next, you enter in the command
 which will be executed when that stroke is invoked.  Simple as that.
 For now, try to define a stroke to copy a region.  This is a popular
 edit command, so type
 
-> M-x global-set-stroke
+> M-x strokes-global-set-stroke
 
 Then, in the ` *strokes*' buffer, draw the letter `C' (for `copy')
 and then, when it asks you to enter the command to map that to, type
@@ -1089,21 +928,18 @@ and then, when it asks you to enter the command to map that to, type
 > copy-region-as-kill
 
 That's about as hard as it gets.
-Remember: paint with button1 or button2 and then end with button3.
+Remember: paint with button 1 or button 2 and then end with button 3.
 
 If ever you want to know what a certain strokes maps to, then do
 
-> M-x describe-stroke
+> M-x strokes-describe-stroke
 
 and you can enter in any arbitrary stroke.  Remember: The strokes
 package lets you program in simple and complex (multi-lift) strokes.
 The only difference is how you *invoke* the two.  You will most likely
 use simple strokes, as complex strokes were developed for
-Chinese/Japanese/Korean.  So the middle mouse button (mouse-2) will
-invoke the command `strokes-do-stroke' in buffers where button2 doesn't
-already have a meaning other than its original, which is `mouse-yank'.
-But don't worry: `mouse-yank' will still work with strokes.  See the
-variable `strokes-click-command'.
+Chinese/Japanese/Korean.  So the shifted middle mouse button (S-mouse-2) will
+invoke the command `strokes-do-stroke'.
 
 If ever you define a stroke which you don't like, then you can unset
 it with the command
@@ -1130,24 +966,23 @@ You can change this location by setting the variable `strokes-file'.
 You will be prompted to save them when you exit Emacs, or you can save
 them with
 
-> M-x save-strokes
+> M-x strokes-save-strokes
 
 Your strokes get loaded automatically when you enable `strokes-mode'.
 You can also load in your user-defined strokes with
 
-> M-x load-user-strokes
+> M-x strokes-load-user-strokes
 
 ** Strokes for pictographic editing...
 
 If you'd like to create graphical files with strokes, you'll have to
-be running a version of Emacs with XPM support.  You use the
-binding C-mouse-2 to start drawing your strokes.  These are just
-complex strokes, and thus you continue drawing with mouse-1 or mouse-2 and
-end with mouse-3-3.  Then the stroke image gets inserted into the
-buffer.  You treat it like any other character, which you can copy,
-paste, delete, move, etc.  The command which is bound to C-mouse-2 is
-called `strokes-compose-complex-stroke'.  When all is done, you may
-want to send the file, or save it.  This is done with
+be running a version of Emacs with XPM support.  You use the binding
+to `strokes-compose-complex-stroke' to start drawing your strokes.
+These are just complex strokes, and thus continue drawing with mouse-1
+or mouse-2 and end with mouse-3.  Then the stroke image gets inserted
+into the buffer.  You treat it somewhat like any other character,
+which you can copy, paste, delete, move, etc.  When all is done, you
+may want to send the file, or save it.  This is done with
 
 > M-x strokes-encode-buffer
 
@@ -1164,47 +999,17 @@ o The command `strokes-do-complex-stroke' is invoked with M-mouse-2,
 o Strokes are a bit computer-dependent in that they depend somewhat on
   the speed of the computer you're working on.  This means that you
   may have to tweak some variables.  You can read about them in the
-  commentary of `strokes.el'.  Better to just use apropos and read their
+  commentary of `strokes.el'.  Better to just use \\[apropos] and read their
   docstrings.  All variables/functions start with `strokes'.  The one
   variable which many people wanted to see was
   `strokes-use-strokes-buffer' which allows the user to use strokes
   silently--without displaying the strokes.  All variables can be set
-  by customizing the group named `strokes' via the customization package:
-
-  > M-x customize"))
-    (with-output-to-temp-buffer "*Help with Strokes*"
-      (princ helpdoc)
-      (set-buffer standard-output)
-      (help-mode)
-      (print-help-return-message))))
+  by customizing the group `strokes' via \[customize-group].")
+    (set-buffer standard-output)
+    (help-mode))
+  (print-help-return-message))
 
-(defun strokes-report-bug ()
-  "Submit a bug report for strokes."
-  (interactive)
-  (let ((reporter-prompt-for-summary-p t))
-    (reporter-submit-bug-report
-     strokes-bug-address "Strokes"
-     (cons
-      'strokes-version
-      (nconc
-       (mapcar
-        'intern
-        (sort
-         (let (completion-ignore-case)
-           (all-completions "strokes-" obarray 'user-variable-p))
-         'string-lessp))
-       (list 'reporter-version)))
-     (function
-      (lambda ()
-        (save-excursion
-          (mail-position-on-field "subject")
-          (beginning-of-line)
-          (skip-chars-forward "^:\n")
-          (if (looking-at ": Strokes;")
-              (progn
-                (goto-char (match-end 0))
-                (delete-char -1)
-                (insert " " strokes-version " bug:")))))))))
+(defalias 'strokes-report-bug 'report-emacs-bug)
 
 (defsubst strokes-fill-current-buffer-with-whitespace ()
   "Erase the contents of the current buffer and fill it with whitespace."
@@ -1216,7 +1021,7 @@ o Strokes are a bit computer-dependent in that they depend somewhat on
 
 (defun strokes-window-configuration-changed-p ()
   "Non-nil if the `strokes-window-configuration' frame properties changed.
-This is based on the last time the `strokes-window-configuration was updated."
+This is based on the last time `strokes-window-configuration' was updated."
   (compare-window-configurations (current-window-configuration)
                                  strokes-window-configuration))
 
@@ -1271,9 +1076,6 @@ This is based on the last time the `strokes-window-configuration was updated."
         (t
          (message "No user-defined strokes, sorry"))))
 
-;;;###autoload
-(defalias 'load-user-strokes 'strokes-load-user-strokes)
-
 (defun strokes-prompt-user-save-strokes ()
   "Save user-defined strokes to file named by `strokes-file'."
   (interactive)
@@ -1295,12 +1097,12 @@ This is based on the last time the `strokes-window-configuration was updated."
                   (emacs-lisp-mode)
                   (goto-char (point-min))
                   (insert
-                   ";;   -*- Syntax: Emacs-Lisp; Mode: emacs-lisp -*-\n")
+                   ";;   -*- emacs-lisp -*-\n")
                   (insert (format ";;; saved strokes for %s, as of %s\n\n"
                                   (user-full-name)
                                   (format-time-string "%B %e, %Y" nil)))
                   (message "Saving strokes in %s..." strokes-file)
-                  (insert (format "(setq strokes-global-map '%s)"
+                  (insert (format "(setq strokes-global-map\n'%s)"
                                   (pp current)))
                   (message "Saving strokes in %s..." strokes-file)
                   (indent-region (point-min) (point-max) nil)
@@ -1313,11 +1115,9 @@ This is based on the last time the `strokes-window-configuration was updated."
             (kill-buffer (get-buffer "*saved-strokes*")))
         (setq strokes-global-map current)))))
 
-(defalias 'save-strokes 'strokes-prompt-user-save-strokes)
-
 (defun strokes-toggle-strokes-buffer (&optional arg)
   "Toggle the use of the strokes buffer.
-In other words, toggle the variabe `strokes-use-strokes-buffer'.
+In other words, toggle the variable `strokes-use-strokes-buffer'.
 With ARG, use strokes buffer if and only if ARG is positive or true.
 Returns value of `strokes-use-strokes-buffer'."
   (interactive "P")
@@ -1326,7 +1126,7 @@ Returns value of `strokes-use-strokes-buffer'."
           (not strokes-use-strokes-buffer))))
 
 (defun strokes-xpm-for-stroke (&optional stroke bufname b/w-only)
-  "Create an xpm pixmap for the given STROKE in buffer ` *strokes-xpm*'.
+  "Create an XPM pixmap for the given STROKE in buffer ` *strokes-xpm*'.
 If STROKE is not supplied, then `strokes-last-stroke' will be used.
 Optional BUFNAME to name something else.
 The pixmap will contain time information via rainbow dot colors
@@ -1366,15 +1166,15 @@ the stroke as a character in some language."
                        (let ((char (or (car rainbow-chars) ?\.)))
                          (loop for i from 0 to 2 do
                                (loop for j from 0 to 2 do
-                                     (goto-line (+ 16 i y))     
+                                     (goto-line (+ 16 i y))
                                      (forward-char (+ 1 j x))
                                      (delete-char 1)
                                      (insert char)))
                          (setq rainbow-chars (cdr rainbow-chars)
                                lift-flag nil))
                      ;; Otherwise, just plot the point...
-                     (goto-line (+ 17 y))       
-                     (forward-char (+ 2 x))     
+                     (goto-line (+ 17 y))
+                     (forward-char (+ 2 x))
                      (subst-char-in-region (point) (1+ (point)) ?\  ?\*)))
                   ((strokes-lift-p point)
                    ;; a lift--tell the loop to X out the next point...
@@ -1386,7 +1186,7 @@ the stroke as a character in some language."
         (put-image (create-image (buffer-string) 'xpm t :ascent 100)
                    (line-end-position))))))
 
-;;; Strokes Edit stuff... ### NOT IMLEMENTED YET ###
+;;; Strokes Edit stuff... ### NOT IMPLEMENTED YET ###
 
 ;;(defun strokes-edit-quit ()
 ;;  (interactive)
@@ -1545,65 +1345,50 @@ If STROKES-MAP is not given, `strokes-global-map' will be used instead."
         (command-name-2 (symbol-name (cdr stroke2))))
     (string-lessp command-name-1 command-name-2)))
 
-;;;###autoload
-(defun strokes-mode (&optional arg)
-  "Toggle strokes being enabled.
-With ARG, turn strokes on if and only if ARG is positive or true.
-Note that `strokes-mode' is a global mode.  Think of it as a minor
-mode in all buffers when activated.
-By default, strokes are invoked with mouse button-2.  You can define
-new strokes with
+(defvar strokes-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map [(shift down-mouse-2)] 'strokes-do-stroke)
+    (define-key map [(meta down-mouse-2)] 'strokes-do-complex-stroke)
+    map))
 
-> M-x global-set-stroke
+;;;###autoload
+(define-minor-mode strokes-mode
+  "Toggle Strokes global minor mode.\\<strokes-mode-map>
+With ARG, turn strokes on if and only if ARG is positive.
+Strokes are pictographic mouse gestures which invoke commands.
+Strokes are invoked with \\[strokes-do-stroke].  You can define
+new strokes with \\[strokes-global-set-stroke].  See also
+\\[strokes-do-complex-stroke] for `complex' strokes.
 
 To use strokes for pictographic editing, such as Chinese/Japanese, use
-S-mouse-2, which draws strokes and inserts them.  Encode/decode your
-strokes with
+\\[strokes-compose-complex-stroke], which draws strokes and inserts them.
+Encode/decode your strokes with \\[strokes-encode-buffer],
+\\[strokes-decode-buffer].
+
+\\{strokes-mode-map}"
+  nil strokes-modeline-string strokes-mode-map
+  :group 'strokes :global t
+  (cond ((not (display-mouse-p))
+         (error "Can't use Strokes without a mouse"))
+        (strokes-mode                   ; turn on strokes
+         (and (file-exists-p strokes-file)
+              (null strokes-global-map)
+              (strokes-load-user-strokes))
+         (add-hook 'kill-emacs-query-functions
+                   'strokes-prompt-user-save-strokes)
+         (add-hook 'select-frame-hook
+                   'strokes-update-window-configuration)
+         (strokes-update-window-configuration))
+        (t                              ; turn off strokes
+         (if (get-buffer strokes-buffer-name)
+             (kill-buffer (get-buffer strokes-buffer-name)))
+         (remove-hook 'select-frame-hook
+                      'strokes-update-window-configuration))))
 
-> M-x strokes-encode-buffer
-> M-x strokes-decode-buffer"
-  (interactive "P")
-  (let ((on-p (if arg
-                  (> (prefix-numeric-value arg) 0)
-                (not strokes-mode))))
-    (cond ((not (display-mouse-p))
-           (error "Can't use strokes without a mouse"))
-          (on-p                         ; turn on strokes
-           (strokes-insinuate)          ; make sure defadvices are set
-           (and (file-exists-p strokes-file)
-                (null strokes-global-map)
-                (strokes-load-user-strokes))
-           (add-hook 'kill-emacs-query-functions
-                     'strokes-prompt-user-save-strokes)
-           (add-hook 'select-frame-hook
-                     'strokes-update-window-configuration)
-           (strokes-update-window-configuration)
-           (define-key global-map [(down-mouse-2)] 'strokes-do-stroke)
-           (define-key global-map [(meta down-mouse-2)]
-             'strokes-do-complex-stroke)
-           ;;      (define-key global-map [(control down-mouse-2)] 'strokes-do-complex-stroke)
-           (ad-activate-regexp "^strokes-") ; advise button2 commands
-           (setq strokes-mode t))
-          (t                            ; turn off strokes
-           (if (get-buffer strokes-buffer-name)
-               (kill-buffer (get-buffer strokes-buffer-name)))
-           (remove-hook 'select-frame-hook
-                        'strokes-update-window-configuration)
-           (if (string-match "^strokes-" (symbol-name (key-binding [(down-mouse-2)])))
-               (define-key global-map [(down-mouse-2)] strokes-click-command))
-           (if (string-match "^strokes-" (symbol-name (key-binding [(meta down-mouse-2)])))
-               (global-unset-key [(meta down-mouse-2)]))
-           (if (string-match "^strokes-" (symbol-name (key-binding [(control down-mouse-2)])))
-               (global-unset-key [(control down-mouse-2)]))
-           ;;      (if (string-match "^strokes-" (symbol-name (key-binding [(shift button2)]))) 
-           ;;          (global-unset-key [(shift button2)]))
-           (ad-deactivate-regexp "^strokes-") ; unadvise strokes-button2 commands
-           (setq strokes-mode nil))))
-  (force-mode-line-update))
 
 ;;;; strokes-xpm stuff (later may be separate)...
 
-;; This is the stuff that will eventuall be used for composing letters in
+;; This is the stuff that will eventually be used for composing letters in
 ;; any language, compression, decompression, graphics, editing, etc.
 
 (defface strokes-char-face '((t (:background "lightgray")))
@@ -1679,7 +1464,7 @@ strokes with
 
 (defconst strokes-base64-chars
   ;; I wanted to make this a vector of individual like (vector ?0
-  ;; ?1 ?2 ...), but `concat' in XEmacs-20.* refuses to accept single
+  ;; ?1 ?2 ...), but `concat' refuses to accept single
   ;; characters.
   (vector "0" "1" "2" "3" "4" "5" "6" "7" "8" "9"
           "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o"
@@ -1696,11 +1481,11 @@ strokes with
   "Character vector for fast lookup of base-64 encoding of numbers in [0,61].")
 
 (defsubst strokes-xpm-char-on-p (char)
-  "Non-nil if CHAR represents an `on' bit in the xpm."
+  "Non-nil if CHAR represents an `on' bit in the XPM."
   (eq char ?*))
 
 (defsubst strokes-xpm-char-bit-p (char)
-  "Non-nil if CHAR represents an `on' or `off' bit in the xpm."
+  "Non-nil if CHAR represents an `on' or `off' bit in the XPM."
   (or (eq char ?\ )
       (eq char ?*)))
 
@@ -1711,7 +1496,7 @@ strokes with
 ;;  (eq (null a) (not (null b))))
 
 (defsubst strokes-xpm-encode-length-as-string (length)
-  "Given some LENGTH in [0,62) do a fast lookup of it's encoding."
+  "Given some LENGTH in [0,62) do a fast lookup of its encoding."
   (aref strokes-base64-chars length))
                    
 (defsubst strokes-xpm-decode-char (character)
@@ -1719,10 +1504,10 @@ strokes with
   (aref strokes-char-table character))
                    
 (defun strokes-xpm-to-compressed-string (&optional xpm-buffer)
-  "Convert the xpm in XPM-BUFFER into a compressed string representing the stroke.
-XPM-BUFFER is an optional argument, and defaults to `*strokes-xpm*'."
+  "Convert XPM in XPM-BUFFER to compressed string representing the stroke.
+XPM-BUFFER defaults to ` *strokes-xpm*'."
   (save-excursion
-    (set-buffer (setq xpm-buffer (or xpm-buffer "*strokes-xpm*")))
+    (set-buffer (setq xpm-buffer (or xpm-buffer " *strokes-xpm*")))
     (goto-char (point-min))
     (search-forward "/* pixels */")     ; skip past header junk
     (forward-char 2)
@@ -1742,19 +1527,19 @@ XPM-BUFFER is an optional argument, and defaults to `*strokes-xpm*'."
                ;; check to see if the `char-at-point' is an actual pixmap bit
                (when (strokes-xpm-char-bit-p char-at-point)
                  (setq count 1
-                       current-char-is-on-p (strokes-xpm-char-on-p char-at-point)))            
+                       current-char-is-on-p (strokes-xpm-char-on-p char-at-point)))
                (forward-char 1))
               ((= count 61)             ; maximum single char's
                                         ; encoding length
-               (setq compressed-string (concat compressed-string
-                                               ;; add a zero-length
-                                               ;; encoding when
-                                               ;; necessary
-                                               (when (eq last-char-was-on-p
-                                                         current-char-is-on-p)
-                                                 ;; "0"
-                                                 (strokes-xpm-encode-length-as-string 0))
-                                               (strokes-xpm-encode-length-as-string 61))
+               (setq compressed-string
+                     (concat compressed-string
+                             ;; add a zero-length encoding when
+                             ;; necessary
+                             (when (eq last-char-was-on-p
+                                       current-char-is-on-p)
+                               ;; "0"
+                               (strokes-xpm-encode-length-as-string 0))
+                             (strokes-xpm-encode-length-as-string 61))
                      last-char-was-on-p current-char-is-on-p
                      count 0))          ; note that we just set
                                         ; count=0 and *don't* advance
@@ -1774,15 +1559,15 @@ XPM-BUFFER is an optional argument, and defaults to `*strokes-xpm*'."
                  ;; iteration go through and letting the case: count=0
                  ;; take care of this stuff for me.  That's why
                  ;; there's no (forward-char 1) below.
-                 (setq compressed-string (concat compressed-string
-                                                 ;; add a zero-length
-                                                 ;; encoding when
-                                                 ;; necessary
-                                                 (when (eq last-char-was-on-p
-                                                           current-char-is-on-p)
-                                                   ;; "0"
-                                                   (strokes-xpm-encode-length-as-string 0))
-                                                 (strokes-xpm-encode-length-as-string count))
+                 (setq compressed-string
+                       (concat compressed-string
+                               ;; add a zero-length encoding when
+                               ;; necessary
+                               (when (eq last-char-was-on-p
+                                         current-char-is-on-p)
+                                 ;; "0"
+                                 (strokes-xpm-encode-length-as-string 0))
+                               (strokes-xpm-encode-length-as-string count))
                        count 0
                        last-char-was-on-p current-char-is-on-p)))
               (t                        ; ELSE it's some other useless
@@ -1816,7 +1601,7 @@ Optional FORCE non-nil will ignore the buffer's read-only status."
         (message "Strokifying %s..." buffer)
         (goto-char (point-min))
         (let (ext string image)
-          ;; The comment below is what i'd have to do if I wanted to
+          ;; The comment below is what I'd have to do if I wanted to
           ;; deal with random newlines in the midst of the compressed
           ;; strings.  If I do this, I'll also have to change
           ;; `strokes-xpm-to-compress-string' to deal with the newline,
@@ -1840,7 +1625,7 @@ Optional FORCE non-nil will ignore the buffer's read-only status."
         (message "Strokifying %s...done" buffer)))))
 
 (defun strokes-encode-buffer (&optional buffer force)
-  "Convert the glyphs in BUFFER to thier base-64 ASCII representations.
+  "Convert the glyphs in BUFFER to their base-64 ASCII representations.
 Optional BUFFER defaults to the current buffer.
 Optional FORCE non-nil will ignore the buffer's read-only status."
   ;; ### NOTE !!! ### (for me)
@@ -1889,10 +1674,10 @@ Optional FORCE non-nil will ignore the buffer's read-only status."
         (message "Encoding strokes in %s...done" buffer)))))
 
 (defun strokes-xpm-for-compressed-string (compressed-string &optional bufname)
-  "Convert the stroke represented by COMPRESSED-STRING into an xpm.
-Store xpm in buffer BUFNAME if supplied \(default is `*strokes-xpm*'\)"
+  "Convert the stroke represented by COMPRESSED-STRING into an XPM.
+Store XPM in buffer BUFNAME if supplied \(default is ` *strokes-xpm*'\)"
   (save-excursion
-    (or bufname (setq bufname "*strokes-xpm*"))
+    (or bufname (setq bufname " *strokes-xpm*"))
     (set-buffer (get-buffer-create bufname))
     (erase-buffer)
     (insert compressed-string)
@@ -1917,7 +1702,7 @@ Store xpm in buffer BUFNAME if supplied \(default is `*strokes-xpm*'\)"
 ;;;###autoload
 (defun strokes-compose-complex-stroke ()
   ;; ### NOTE !!! ###
-  ;; Even though we have lexical scoping, it's somewhat ugly how I
+  ;; Even though we don't have lexical scoping, it's somewhat ugly how I
   ;; pass around variables in the global name space.  I can/should
   ;; change this.
   "Read a complex stroke and insert its glyph into the current buffer."
@@ -1930,11 +1715,11 @@ Store xpm in buffer BUFNAME if supplied \(default is `*strokes-xpm*'\)"
     ;; strokes-decode-buffer does a save-excursion.
     (forward-char)))
 
-(or (assq 'strokes-mode minor-mode-alist)
-    (setq minor-mode-alist (cons (list 'strokes-mode strokes-modeline-string)
-                                 minor-mode-alist)))
+(defun strokes-unload-hook ()
+  (strokes-mode -1)
+  (remove-hook 'kill-emacs-query-functions 'strokes-prompt-user-save-strokes))
 
-(provide 'strokes)
 (run-hooks 'strokes-load-hook)
+(provide 'strokes)
 
 ;;; strokes.el ends here