Many changes.

1 files changed, 205 insertions, 201 deletions

diff --git a/lisp/strokes.el b/lisp/strokes.el
index b9dc400f3ff..bca84e5bb3b 100644
--- a/lisp/strokes.el
+++ b/lisp/strokes.el
@@ -1,10 +1,9 @@
-;;; strokes.el	-- Control Emacs through mouse strokes --
+;;; strokes.el --- control Emacs through mouse strokes
 
 ;; Copyright (C) 1997 Free Software Foundation, Inc.
 
 ;; Author: David Bakhash <cadet@mit.edu>
 ;; Maintainer: David Bakhash <cadet@mit.edu>
-;; Created: 12 April 1997
 ;; Keywords: lisp, mouse, extensions
 
 ;; This file is part of GNU Emacs.
@@ -195,10 +194,9 @@
 
 (autoload 'reporter-submit-bug-report "reporter")
 (autoload 'mail-position-on-field "sendmail")
-(eval-when-compile
-  (mapcar 'require '(pp reporter advice)))
-
-(require 'levents)
+(eval-and-compile
+  (mapcar 'require '(pp reporter advice custom cl))
+  (mapcar 'load '("cl-macs" "cl-seq" "levents")))
 
 ;;; Constants...
 
@@ -213,6 +211,14 @@ This will be useful for when Emacs understands Chinese.")
 
 ;;; user variables...
 
+;; suggested Custom hack, so strokes is compatible with emacs19...
+
+(eval-and-compile
+  (if (fboundp 'defgroup) nil 
+    (defmacro defgroup (&rest forms) nil)  
+    (defmacro defcustom (name init doc &rest forms)  
+      (list 'defvar name init doc))))
+
 (defgroup strokes nil
   "Control Emacs through mouse strokes"
   :group 'mouse)
@@ -224,7 +230,7 @@ This will be useful for when Emacs understands Chinese.")
 
 (defcustom strokes-character ?@
   "*Character used when drawing strokes in the strokes buffer.
-\(The default is lower-case `o', which works okay\)."
+\(The default is lower-case `@', which works okay\)."
   :type 'character
   :group 'strokes)
 
@@ -316,12 +322,12 @@ corresponding interactive function")
 
 (defsubst strokes-click-p (stroke)
   "Non-nil if STROKE is really click."
-  (< (length stroke) 3))
+  (< (length stroke) 2))
 
 ;;; old, but worked pretty good (just in case)...
 ;;(defmacro strokes-define-stroke (stroke-map stroke def)
 ;;  "Add STROKE to STROKE-MAP alist with given command DEF"
-;;  (list 'if (list '< (list 'length stroke) 3)
+;;  (list 'if (list '< (list 'length stroke) 2)
 ;;	(list 'error
 ;;	      "That's a click, not a stroke.  See `strokes-click-command'")
 ;;	(list 'setq stroke-map (list 'cons (list 'cons stroke def)
@@ -407,7 +413,7 @@ and which is an interactive funcion of one event argument:
              ;; 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
+	   (let ((strokes-click-command
                   ',(intern (format "ad-Orig-%s" command))))
              (strokes-do-stroke (ad-get-arg 0))))))))
 
@@ -494,7 +500,7 @@ or for window WINDOW if that is specified."
 	    (if (windowp end-w)
 		(nth 1 (window-edges end-w))
 	      (/ (cdr (posn-x-y (event-end event)))
-		 ((frame-char-height end-w)))))
+		 (frame-char-height end-w))))
       (if (>= end-w-top w-top)
 	  (strokes-event-closest-point-1 start-window)
 	(window-start start-window)))))
@@ -507,7 +513,7 @@ or for window WINDOW if that is specified."
   "Undo the last stroke definition."
   (interactive)
   (let ((command (cdar strokes-global-map)))
-    (if (y-or-n-p-maybe-dialog-box
+    (if (y-or-n-p
 	 (format "really delete last stroke definition, defined to `%s'? "
 		 command))
 	(progn
@@ -829,109 +835,110 @@ Optional PROMPT in minibuffer displays before and during stroke reading.
 This function will display the stroke interactively as it is being
 entered in the strokes buffer if the variable
 `strokes-use-strokes-buffer' is non-nil.
-Optional EVENT is currently not used, but hopefully will be soon."
+Optional EVENT is acceptable as the starting event of the stroke"
   (save-excursion
-    (track-mouse
-      (let ((pix-locs nil)
-	    (grid-locs nil)
-	    (event nil))
-	(if strokes-use-strokes-buffer
-	    ;; switch to the strokes buffer and
-	    ;; display the stroke as it's being read
-	    (save-window-excursion
-	      (set-window-configuration strokes-window-configuration)
-	      (if prompt
-		  (progn
-		    (message prompt)
-		    (setq event (read-event))
-		    (while (not (button-press-event-p event))
-		      (setq event (read-event)))))
-	      (unwind-protect
-		  (progn
-		    (setq event (read-event))
-		    (while (not (button-release-event-p event))
-		      (if (strokes-mouse-event-p event)
-			  (let ((point (strokes-event-closest-point event)))
-			    (when point
-			      (goto-char point)
-			      (subst-char-in-region point (1+ point) ?\  strokes-character))
-			    (push (cons (event-x-pixel event)
-					(event-y-pixel event))
-				  pix-locs)))
-		      (setq event (read-event))))
-		;; 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 ?\ )
-		  (goto-char (point-min))
-		  (bury-buffer))))
-	  ;; Otherwise, don't use strokes buffer and read stroke silently
-	  (if prompt
-	      (progn
-		(message prompt)
-		(setq event (read-event))
-		(while (not (button-press-event-p event))
-		  (setq event (read-event)))))
-	  (setq event (read-event))
-	  (while (not (button-release-event-p event))
-	    (if (strokes-mouse-event-p event)
-		(push (cons (event-x-pixel event)
-			    (event-y-pixel event))
-		      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))))))
-
-;;;###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.
-Optional EVENT is currently not used, but hopefully will be soon."
-  (save-excursion
-    (save-window-excursion
-      (track-mouse
-	(set-window-configuration strokes-window-configuration)
-	(let ((pix-locs nil)
-	      (grid-locs nil)
-	      (event (or event (read-event))))
-	  (if prompt
-	      (while (not (button-press-event-p event))
-		(message prompt)
-		(setq event (read-event))))
-	  (unwind-protect
-	      (progn
-		(setq event (read-event))
-		(while (not (and (button-press-event-p event)
-				 (eq (event-button event) 3)))
+    (let ((pix-locs nil)
+	  (grid-locs nil)
+	  (safe-to-draw-p nil))
+      (if strokes-use-strokes-buffer
+	  ;; switch to the strokes buffer and
+	  ;; display the stroke as it's being read
+	  (save-window-excursion
+	    (set-window-configuration strokes-window-configuration)
+	    (when prompt
+	      (message prompt)
+	      (setq event (read-event))
+	      (or (button-press-event-p event)
+		  (error "You must draw with the mouse")))
+	    (unwind-protect
+		(track-mouse
+		  (or event (setq event (read-event)
+				  safe-to-draw-p t))
 		  (while (not (button-release-event-p event))
 		    (if (strokes-mouse-event-p event)
 			(let ((point (strokes-event-closest-point event)))
-			  (when point
-			    (goto-char point)
-			    (subst-char-in-region point (1+ point) ?\ strokes-character))
+			  (if (and point safe-to-draw-p)
+			      ;; we can draw that point
+			      (progn
+				(goto-char point)
+				(subst-char-in-region point (1+ point) ?\  strokes-character))
+			    ;; otherwise, we can start drawing the next time...
+			    (setq safe-to-draw-p t))
 			  (push (cons (event-x-pixel event)
 				      (event-y-pixel event))
 				pix-locs)))
-		    (setq event (read-event)))
-		  (push strokes-lift pix-locs)
-		  (while (not (button-press-event-p event))
-		    (setq event (read-event))))
-		;; ### KLUDGE! ### sit and wait
-		;; for some useless event to
-		;; happen to fix the minibuffer bug.
-		(while (not (button-release-event-p (read-event))))
-		(setq pix-locs (nreverse (cdr pix-locs))
-		      grid-locs (strokes-renormalize-to-grid pix-locs))
-		(strokes-fill-stroke
-		 (strokes-eliminate-consecutive-redundancies grid-locs)))
+		    (setq event (read-event)))))
 	    ;; 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 ?\ )
 	      (goto-char (point-min))
-	      (bury-buffer))))))))
+	      (bury-buffer))))
+      ;; Otherwise, don't use strokes buffer and read stroke silently
+      (when prompt
+	(message prompt)
+	(setq event (read-event))
+	(or (button-press-event-p event)
+	    (error "You must draw with the mouse")))
+      (track-mouse
+	(or event (setq event (read-event)))
+	(while (not (button-release-event-p event))
+	  (if (strokes-mouse-event-p event)
+	      (push (cons (event-x-pixel event)
+			  (event-y-pixel event))
+		    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)))))
+
+;;;###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.
+Optional EVENT is acceptable as the starting event of the stroke"
+  (save-excursion
+    (save-window-excursion
+      (set-window-configuration strokes-window-configuration)
+      (let ((pix-locs nil)
+	    (grid-locs nil))
+	(if prompt
+	    (while (not (button-press-event-p event))
+	      (message prompt)
+	      (setq event (read-event))))
+	(unwind-protect
+	    (track-mouse
+	      (or event (setq event (read-event)))
+	      (while (not (and (button-press-event-p event)
+			       (eq (event-button event) 3)))
+		(while (not (button-release-event-p event))
+		  (if (strokes-mouse-event-p event)
+		      (let ((point (strokes-event-closest-point event)))
+			(when point
+			  (goto-char point)
+			  (subst-char-in-region point (1+ point) ?\ strokes-character))
+			(push (cons (event-x-pixel event)
+				    (event-y-pixel event))
+			      pix-locs)))
+		  (setq event (read-event)))
+		(push strokes-lift pix-locs)
+		(while (not (button-press-event-p event))
+		  (setq event (read-event))))
+	      ;; ### KLUDGE! ### sit and wait
+	      ;; for some useless event to
+	      ;; happen to fix the minibuffer bug.
+	      (while (not (button-release-event-p (read-event))))
+	      (setq pix-locs (nreverse (cdr pix-locs))
+		    grid-locs (strokes-renormalize-to-grid pix-locs))
+	      (strokes-fill-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 ?\ )
+	    (goto-char (point-min))
+	    (bury-buffer)))))))
 
 (defun strokes-execute-stroke (stroke)
   "Given STROKE, execute the command which corresponds to it.
@@ -949,7 +956,7 @@ If no stroke matches, nothing is done and return value is nil."
 	   (command-execute command))
 	  ((null strokes-global-map)
 	   (if (file-exists-p strokes-file)
-	       (and (y-or-n-p-maybe-dialog-box
+	       (and (y-or-n-p
 		     (format "No strokes loaded.  Load `%s'? "
 			     strokes-file))
 		    (strokes-load-user-strokes))
@@ -998,122 +1005,121 @@ This must be bound to a mouse event."
 ;;;###autoload
 (defalias 'describe-stroke 'strokes-describe-stroke)
 
-;;; ### FORGET IT!  I COULN'T GET THE EMACS READER TO PARSE THIS FUNCTION ###
 ;;;###autoload
-;;(defun strokes-help ()
-;;  "Get instructional help on using the the `strokes' package."
-;;  (interactive)
-;;  (with-output-to-temp-buffer "*Help with Strokes*"
-;;    (let ((helpdoc
-;;	   "This is help for the strokes package.
+(defun strokes-help ()
+  "Get instructional help on using the the `strokes' package."
+  (interactive)
+  (with-output-to-temp-buffer "*Help with Strokes*"
+    (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:
+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>
+David Bakhash <cadet@mit.edu>
 
-;;or just do
+or just do
 
-;;M-x strokes-report-bug
+M-x strokes-report-bug
 
-;;------------------------------------------------------------
+------------------------------------------------------------
 
-;;** Strokes...
+** Strokes...
 
-;;The strokes package allows you to define strokes, made with
-;;the mouse or other pointer device, that Emacs can interpret as
-;;corresponding to commands, and then executes the commands.  It does
-;;character recognition, so you don't have to worry about getting it
-;;right every time.
+The strokes package allows you to define strokes, made with
+the mouse or other pointer device, that Emacs can interpret as
+corresponding to commands, and then executes the commands.  It does
+character recognition, so you don't have to worry about getting it
+right every time.
 
-;;Strokes are easy to program and fun to use.  To start strokes going,
-;;you'll want to put the following line in your .emacs file as mentioned
-;;in the commentary to strokes.el.
+Strokes are easy to program and fun to use.  To start strokes going,
+you'll want to put the following line in your .emacs file as mentioned
+in the commentary to strokes.el.
 
-;;This will load strokes when and only when you start Emacs on a window
-;;system, with a mouse or other pointer device defined.
+This will load strokes when and only when you start Emacs on a window
+system, with a mouse or other pointer device defined.
 
-;;To toggle strokes-mode, you just do
+To toggle strokes-mode, you just do
 
-;;> M-x strokes-mode
+> M-x strokes-mode
 
-;;** Strokes for controling the behavior of Emacs...
+** Strokes for controling the behavior of Emacs...
 
-;;When you're ready to start defining strokes, just use the command
+When you're ready to start defining strokes, just use the command
 
-;;> M-x global-set-stroke
+> M-x 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
-;;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
+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
+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 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
+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
 
-;;> copy-region-as-kill
+> copy-region-as-kill
 
-;;That's about as hard as it gets.
-;;Remember: paint with button1 or button2 and then end with button3.
+That's about as hard as it gets.
+Remember: paint with button1 or button2 and then end with button3.
 
-;;If ever you want to know what a certain strokes maps to, then do
+If ever you want to know what a certain strokes maps to, then do
 
-;;> M-x describe-stroke
+> M-x describe-stroke
 
-;;and you can enter in any arbitrary stroke.  Remember: The strokes
-;;package lets you program in simple and complex, or 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, button2, 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'.
+and you can enter in any arbitrary stroke.  Remember: The strokes
+package lets you program in simple and complex, or 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, button2, 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'.
 
-;;If ever you define a stroke which you don't like, then you can unset
-;;it with the command
+If ever you define a stroke which you don't like, then you can unset
+it with the command
 
-;;> M-x strokes-unset-last-stroke
+> M-x strokes-unset-last-stroke
 
-;;Your strokes are stored as you enter them.  They get saved in a file
-;;called ~/.strokes, along with other strokes configuration variables.
-;;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
+Your strokes are stored as you enter them.  They get saved in a file
+called ~/.strokes, along with other strokes configuration variables.
+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 save-strokes
 
-;;Your strokes get loaded automatically when you enable `strokes-mode'.
-;;You can also load in your user-defined strokes with
+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 load-user-strokes
 
-;;** A few more important things...
+** A few more important things...
 
-;;o The command `strokes-do-stroke' is also invoked with M-button2, so that you
-;;  can still enter a stroke in modes which use button2 for other things,
-;;  such as cross-referencing.
+o The command `strokes-do-stroke' is also invoked with M-button2, so that you
+  can still enter a stroke in modes which use button2 for other things,
+  such as cross-referencing.
 
-;;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
-;;  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:
+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
+  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"))
-;;    (save-excursion
-;;	(princ helpdoc)
-;;	(set-buffer standard-output)
-;;	(help-mode))
-;;      (print-help-return-message)))))
+  > M-x customize"))
+    (save-excursion
+	(princ helpdoc)
+	(set-buffer standard-output)
+	(help-mode))
+      (print-help-return-message))))
 
 (defun strokes-report-bug ()
   "Submit a bug report for strokes."
@@ -1164,7 +1170,7 @@ This must be bound to a mouse event."
 	   ;; if window is dedicated or a minibuffer
 	   nil)
 	  ((or (interactive-p)
-	       (not (buffer-live-p (get-buffer strokes-buffer-name)))
+	       (not (bufferp (get-buffer strokes-buffer-name)))
 	       (null strokes-window-configuration))
 	   ;; create `strokes-window-configuration' from scratch...
 	   (save-excursion
@@ -1218,7 +1224,7 @@ This must be bound to a mouse event."
 	    (strokes-load-user-strokes)
 	    (if (and (not (equal current strokes-global-map))
 		     (or (interactive-p)
-			 (yes-or-no-p-maybe-dialog-box "save your strokes? ")))
+			 (yes-or-no-p "save your strokes? ")))
 		(progn
 		  (require 'pp)		; pretty-print variables
 		  (message "Saving strokes in %s..." strokes-file)
@@ -1285,14 +1291,14 @@ strokes with
 	   (and (file-exists-p strokes-file)
 		(null strokes-global-map)
 		(strokes-load-user-strokes))
-	   (add-hook 'kill-emacs-hook
+	   (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 [(button2)] 'strokes-do-stroke)
-	   (define-key global-map [(meta button2)] 'strokes-do-stroke)
-	   ;;	   (define-key global-map [(control button2)] 'strokes-do-complex-stroke)
+	   (define-key global-map [(down-mouse-2)] 'strokes-do-stroke)
+	   (define-key global-map [(meta down-mouse-2)] 'strokes-do-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
@@ -1300,9 +1306,9 @@ strokes with
 	       (kill-buffer (get-buffer strokes-buffer-name)))
 	   (remove-hook 'select-frame-hook
 			'strokes-update-window-configuration)
-	   (if (string-match "^strokes-" (symbol-name (key-binding [(button2)])))
-	       (define-key global-map [(button2)] strokes-click-command))
-	   (if (string-match "^strokes-" (symbol-name (key-binding [(meta button2)])))
+	   (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 button2)]))
 	   ;;	   (if (string-match "^strokes-" (symbol-name (key-binding [(shift button2)])))	
 	   ;;	       (global-unset-key [(shift button2)]))
@@ -1311,12 +1317,10 @@ strokes with
   (force-mode-line-update))
 
 (or (assq 'strokes-mode minor-mode-alist)
-(setq minor-mode-alist (cons (list 'strokes-mode strokes-modeline-string)
-			     minor-mode-alist)))
+    (setq minor-mode-alist (cons (list 'strokes-mode strokes-modeline-string)
+				 minor-mode-alist)))
 
 (provide 'strokes)
 (run-hooks 'strokes-load-hook)
 
 ;;; strokes.el ends here
-
-