;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(autoload 'mail-position-on-field "sendmail")
#@130 Symbol representing a stroke lift event for complex strokes.
Complex strokes are those which contain two or more simple strokes.
(defconst strokes-lift :strokes-lift (#$ . 131))
#@51 The header to all XPM buffers created by strokes.
(defconst strokes-xpm-header "/* XPM */\nstatic char * stroke_xpm[] = {\n/* width height ncolors cpp [x_hot y_hot] */\n\"33 33 9 1 26 23\",\n/* colors */\n\" 	c none s none\",\n\"*	c #000000 s foreground\",\n\"R	c #FFFF00000000\",\n\"O	c #FFFF80000000\",\n\"Y	c #FFFFFFFF0000\",\n\"G	c #0000FFFF0000\",\n\"B	c #00000000FFFF\",\n\"P	c #FFFF0000FFFF\",\n\".	c #45458B8B0000\",\n/* pixels */\n" (#$ . 315))
(byte-code "\300\301\302\303\304\305\306\307&\210\310\311\312\302#\210\313\211\2033\211@\311
N\203,\312
N\204,\314\312\311N#\210
A\266\202\202\210\315\311\312\316#\210\317\312\320\321\322DD\323\324\325%\210\317\326\320\321\327DD\330\324\331%\210\317\332\320\321\333DD\334\324\335%\210\317\336\320\321\337DD\340\324\335%\210\317\341\320\321\342DD\343\344\345\324\346&\207" [custom-declare-group strokes nil "Control Emacs through mouse strokes." :link (emacs-commentary-link "strokes") :group mouse defvaralias strokes-modeline-string strokes-lighter (saved-value saved-variable-comment) put make-obsolete-variable "24.3" custom-declare-variable funcall function #[0 "\300\207" [" Strokes"] 1 #1=""] "Mode line identifier for Strokes mode." :type string strokes-character #[0 "\300\207" [64] 1 #1#] "Character used when drawing strokes in the strokes buffer.\n(The default is `@', which works well.)" character strokes-minimum-match-score #[0 "\300\207" [1000] 1 #1#] "Minimum score for a stroke to be considered a possible match.\nSetting this variable to 0 would require a perfectly precise match.\nThe default value is 1000, but it's mostly dependent on how precisely\nyou manage to replicate your user-defined strokes.  It also depends on\nthe value of `strokes-grid-resolution', since a higher grid resolution\nwill correspond to more sample points, and thus more distance\nmeasurements.  Usually, this is not a problem since you first set\n`strokes-grid-resolution' based on what your computer seems to be able\nto handle (though the defaults are usually more than sufficient), and\nthen you can set `strokes-minimum-match-score' to something that works\nfor you.  The only purpose of this variable is to insure that if you\ndo a bogus stroke that really doesn't match any of the predefined\nones, then strokes should NOT pick the one that came closest." integer strokes-grid-resolution #[0 "\300\207" [9] 1 #1#] "Integer defining dimensions of the stroke grid.\nThe grid is a square grid, where `strokes-grid-resolution' defaults to\n`9', making a 9x9 grid whose coordinates go from (0 . 0) on the top\nleft to ((strokes-grid-resolution - 1) . (strokes-grid-resolution - 1))\non the bottom right.  The greater the resolution, the more intricate\nyour strokes can be.\nNOTE: This variable should be odd and MUST NOT be less than 3 and need\n      not be greater than 33, which is the resolution of the pixmaps.\nWARNING: Changing the value of this variable will gravely affect the\n         strokes you have already programmed in.  You should try to\n         figure out what it should be based on your needs and on how\n         quick the particular platform(s) you're operating on, and\n         only then start programming in your custom strokes." strokes-file #[0 "\300\301\302\"\207" [locate-user-emacs-file "strokes" ".strokes"] 3 #1#] "File containing saved strokes for Strokes mode." :version "24.4" file] 8)
#@56 The name of the buffer that the strokes take place in.
(defvar strokes-buffer-name " *strokes*" (#$ . 3706))
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable strokes-use-strokes-buffer funcall function #[0 "\300\207" [t] 1 ""] "If non-nil, the strokes buffer is used and strokes are displayed.\nIf nil, strokes will be read the same, however the user will not be\nable to see the strokes.  This be helpful for people who don't like\nthe delay in switching to the strokes buffer." :type boolean] 6)
#@138 The special window configuration used when entering strokes.
This is set properly in the function `strokes-update-window-configuration'.
(defvar strokes-window-configuration nil (#$ . 4240))
#@161 Last stroke entered by the user.
Its value gets set every time the function `strokes-fill-stroke'
gets called, since that is the best time to set the variable.
(defvar strokes-last-stroke nil (#$ . 4438))
#@288 Association list of strokes and their definitions.
Each entry is (STROKE . COMMAND) where STROKE is itself a list of
coordinates (X . Y) where X and Y are lists of positions on the
normalized stroke grid, with the top left at (0 . 0).  COMMAND is
the corresponding interactive function.
(defvar strokes-global-map nil (#$ . 4650))
#@48 Functions to be called when Strokes is loaded.
(defvar strokes-load-hook nil (#$ . 4987))
(make-obsolete-variable 'strokes-load-hook "use `with-eval-after-load' instead." "28.1")
#@49 Non-nil if STROKE is really click.

(fn STROKE)
(defalias 'strokes-click-p #[257 "\211G\300W\207" [2] 3 (#$ . 5172)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-click-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@17 

(fn KEY LIST)
(defalias 'strokes-remassoc #[514 "\300\301\"\211\262\203\302
\"\262\202
\210\207" [nil assoc delete] 6 (#$ . 5437)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-remassoc speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@84 Add STROKE to STROKE-MAP alist with given command DEF.

(fn STROKE-MAP STROKE DEF)
(defalias 'strokes-define-stroke '(macro . #[771 "\300\301D\302\303\304\211E\305	EEEF\207" [if strokes-click-p (error "That's a click, not a stroke") setq cons strokes-remassoc] 13 (#$ . 5727)]))
#@44 Return the square of the number X.

(fn X)
(defalias 'strokes-square #[257 "\211
_\207" [] 3 (#$ . 6022)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-square speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@119 Compute the distance (squared) between to points P1 and P2.
P1 and P2 are cons cells in the form (X . Y).

(fn P1 P2)
(defalias 'strokes-distance-squared #[514 "
@A@A
Z\211
_\262

Z\211
_\262
\\\207" [] 10 (#$ . 6276)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-distance-squared speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@14 

(fn EVENT)
(defalias 'strokes-mouse-event-p #[257 "\211:\205*\211@9\205*\211@\300=\206*\301
@\302N>\206*\303
@\302N>\206*\304
@\302N>\207" [mouse-movement click event-symbol-elements down drag] 4 (#$ . 6657)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-mouse-event-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@14 

(fn EVENT)
(defalias 'strokes-button-press-event-p #[257 "\211:\205\211@9\205\300
@\301N>\207" [down event-symbol-elements] 4 (#$ . 7027)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-button-press-event-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@14 

(fn EVENT)
(defalias 'strokes-button-release-event-p #[257 "\211:\205\211@9\205\300
@\301N>\206\302
@\301N>\207" [click event-symbol-elements drag] 4 (#$ . 7333)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-button-release-event-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@138 Return position of start of line LINE in WINDOW.
If LINE is nil, return the last position visible in WINDOW.

(fn WINDOW &optional LINE)
(defalias 'strokes-event-closest-point-1 #[513 "\300!\301!\203
\302\202\303Z
\206\211\212\304!b\210\305
!
U\203)\204)\306u\210`)\207" [window-height window-minibuffer-p 0 1 window-start vertical-motion -1] 6 (#$ . 7668)])
#@208 Return the nearest position to where EVENT ended its motion.
This is computed for the window where EVENT's motion started,
or for window START-WINDOW if that is specified.

(fn EVENT &optional START-WINDOW)
(defalias 'strokes-event-closest-point #[513 "\211\204
\300!\211@\262
\262
\211\301!\211@\262
=\203A\302\301!!\303=\203-\304
\305\301!!A\"\207\302\301!!\306=\203;\304
!\207\302\301!!\207\301!\211@\262
\307\310!A@\311!\203\\\310!A@\202i\301!\312
8\262
A\313!\245\262

Y\203u\304!\207\314!\207" [event-start event-end posn-point vertical-line strokes-event-closest-point-1 posn-col-row mode-line nil window-edges windowp 2 frame-char-height window-start] 8 (#$ . 8045)])
#@57 Return non-nil if OBJECT is a stroke-lift.

(fn OBJECT)
(defalias 'strokes-lift-p #[257 "\211=\207" [strokes-lift] 3 (#$ . 8749)])
#@34 Undo the last stroke definition.
(defalias 'strokes-unset-last-stroke #[0 "@A\301\302\303\"!\203A\304\305!\207\304\306!\207" [strokes-global-map y-or-n-p format-message "Really delete last stroke definition, defined to `%s'? " message "That stroke has been deleted" "Nothing done"] 5 (#$ . 8887) nil])
#@377 Interactively give STROKE the global binding as COMMAND.
Works just like `global-set-key', except for strokes.  COMMAND is
a symbol naming an interactively-callable function.  STROKE is a
list of sampled positions on the stroke grid as described in the
documentation for the `strokes-define-stroke' function.

See also `strokes-global-set-stroke-string'.

(fn STROKE COMMAND)
(defalias 'strokes-global-set-stroke #[514 "
\211G\301W\262
\203\302\303!\207

B\304\305\"\211\262\203'\306
\"\262\202\210\262
B\211\207" [strokes-global-map 2 error "That's a click, not a stroke" nil assoc delete] 9 (#$ . 9202) (byte-code "\204\n\300\301!\205
\302\303!\304\305!D\207" [strokes-mode t strokes-read-complex-stroke "Draw with mouse button 1 (or 2).  End with button 3..." read-command "Command to map stroke to: "] 3)])
#@353 Interactively give STROKE the global binding as STRING.
Works just like `global-set-key', except for strokes.  STRING
is a string to be inserted by the stroke.  STROKE is a list of
sampled positions on the stroke grid as described in the
documentation for the `strokes-define-stroke' function.

Compare `strokes-global-set-stroke'.

(fn STROKE STRING)
(defalias 'strokes-global-set-stroke-string #[514 "
\211G\301W\262
\203\302\303!\207

B\304\305\"\211\262\203'\306
\"\262\202\210\262
B\211\207" [strokes-global-map 2 error "That's a click, not a stroke" nil assoc delete] 9 (#$ . 10036) (byte-code "\204\n\300\301!\205
\302\303!\304\305!D\207" [strokes-mode t strokes-read-complex-stroke "Draw with mouse button 1 (or 2).  End with button 3..." read-string "String to map stroke to: "] 3)])
#@400 Map POSITION to a new grid position.
Do so based on its STROKE-EXTENT and GRID-RESOLUTION.
STROKE-EXTENT is 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 dimension is [0,GRID-RESOLUTION).

(fn STROKE-EXTENT POSITION &optional GRID-RESOLUTION)
(defalias 'strokes-get-grid-position #[770 "
:\203E\211\206\n@A@@@AA@@TA@AT\302\303Z!Z\245_!\302\303Z!Z\245_!B\207\304!\205L	\207" [strokes-grid-resolution strokes-lift floor float strokes-lift-p] 16 (#$ . 10852)])
#@154 From a list of absolute PIXEL-POSITIONS, return absolute spatial extent.
The return value is a list ((XMIN . YMIN) (XMAX . YMAX)).

(fn PIXEL-POSITIONS)
(defalias 'strokes-get-stroke-extent #[257 "\211\205\220\211@@
@@@A@AA\211\203Q\211@:\203J\211@@
@A
W\203,
\262
V\2036
\262\211W\203?\211\262\211V\203H\211\262\266\211A\262
\202ZZ

V\203rZ\300\245Z\262Z\300\245\\\262\202\205
Z\300\245Z\262
Z\300\245\\\262BBD\266\207\207" [2] 11 (#$ . 11505)])
#@68 Return a list with no consecutive redundant entries.

(fn ENTRIES)
(defalias 'strokes-eliminate-consecutive-redundancies #[257 "\211\300
:\203
@A@\232\204
@
B\262

A\262\202\211\237\207" [nil] 5 (#$ . 12008)])
#@306 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 dimension is [0,GRID-RESOLUTION).

(fn POSITIONS &optional GRID-RESOLUTION)
(defalias 'strokes-renormalize-to-grid #[513 "\211C\211\242\204\211\240\210\301!\302\303\304#\"\207" [strokes-grid-resolution strokes-get-stroke-extent mapcar make-closure #[257 "\302\301\300\242#\207" [V0 V1 strokes-get-grid-position] 5 "\n\n(fn POS)"]] 9 (#$ . 12233)])
#@246 Fill in missing grid locations in the list of UNFILLED-STROKE.
If FORCE is non-nil, then fill the stroke even if it's `strokes-click-p'.
NOTE: This is where the global variable `strokes-last-stroke' is set.

(fn UNFILLED-STROKE &optional FORCE)
(defalias 'strokes-fill-stroke #[513 "
\211G\301W\262
\203\211\204
\202\304

\302
:\203\300

@\211:A@\211:\205'\211\205-@\2053A\2059@\205?A\205F
Z\205M
Z\205^
\303U?\205^\304
!\245\204kC\266\214\202\264
\211\204\263
\303Y\203\224\302
W\203\215B
B\262

T\262\202w\211\237\266\216\202\264
\302
V\203\254B
B\262

S\262\202\226\211\237\266\216\202\264
\211\303U\203\377\303Y\203\337\302
W\203\330
B
B\262

T\262\202\302\211\237\266\216\202\264
\302
V\203\370
B
B\262

S\262\202\342\211\237\266\216\202\264
\305!\305!Y\203a
\303V\2038
\302
W\2031

\306
Z_!\\B
B\262

T\262\202
\211\237\266\216\202\264
\302
V\203Z

\306
Z_!\\B
B\262

S\262\202;
\211\237\266\216\202\264

\303V\203\217
\302
W\203\210
\306\nZ\245!\\B
B\262

T\262\202i
\211\237\266\216\202\264
\302
V\203\260
\306\nZ\245!\\B
B\262

S\262\202\221
\211\237\266\216\237
\244\262

A\262\202\211\237\266\202\211\207" [strokes-last-stroke 2 nil 0 float abs round] 24 (#$ . 12825)])
#@286 Rate 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.

(fn STROKE1 STROKE2)
(defalias 'strokes-rate-stroke #[514 "
\205x
\211\205x

A
A@@
@A@A
Z\211
_\262

Z\211
_\262
\\\266\206\203\372
\203\372@:\203s
@:\203s\211@@
@A@A
Z\211
_\262

Z\211
_\262
\\\266\206\\\262
\262
\262A\262A\262\2023\300@!\203\214\300@!\203\214A\262
A\262\202+\300@!\203\303@:\203+\211@@
@A@A
Z\211
_\262

Z\211
_\262
\\\266\206\\\262
A\262\202\223\300@!\203+
@:\203+\211@@
@A@A
Z\211
_\262

Z\211
_\262
\\\266\206\\\262

A\262\202\312
\204.
@:\203.
\211@@
@A@A
Z\211
_\262

Z\211
_\262
\\\266\206\\\262
A\262\202\376\204b

@:\203b
\211@@
@A@A
Z\211
_\262

Z\211
_\262
\\\266\206\\\262

A\262\2022
\300@!\204p
\300@!\203u
\301\211\262\207\211\266\203\207" [strokes-lift-p nil] 16 (#$ . 14137)])
#@135 Find the best matching command of STROKE in STROKE-MAP.
Returns the corresponding match as (COMMAND . SCORE).

(fn STROKE STROKE-MAP)
(defalias 'strokes-match-stroke #[514 "
\205K\211\205K\300@@\"
@AA\211\203B\300@@\"\211\203+\203+\211W\2043\211\203;\204;\211\262
@A\262
A\266\202\202\205I
B\266\203\207" [strokes-rate-stroke] 8 (#$ . 15205)])
#@71 Erase the contents of the current buffer and fill it with whitespace.
(defalias 'strokes-fill-current-buffer-with-whitespace #[0 "\300 \210\301 \211S\211\262\302Y\203\303\304\305 S\"\210\306 \210\202\210eb\207" [erase-buffer frame-height 0 insert-char 32 frame-width newline] 4 (#$ . 15578)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-fill-current-buffer-with-whitespace speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@383 Read a simple stroke (interactively) and return the stroke.
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 acceptable as the starting event of the stroke.

(fn &optional PROMPT EVENT)
(defalias 'strokes-read-stroke #[512 "\211C\212\304C\304\211C\203\224\305 \306\307\"\216\310	!\210\311\312\313 \314 Z!V\204C\315 \210\316 \211S\211\262\317Y\203?\320\321\322 S\"\210\323 \210\202(\210eb\210\203o\324\325\"\210\326 \240\210\242\211:\205f\211@9\205f\327
@\330N>\262
\204o\331\332!\210\333\216\334\306\335$!\210)\336 \n\232\203\222\337ed\321$\210eb\210\340 \210)\210\203\277\324\325\"\210\326 \240\210\242\211:\205\266\211@9\205\266\327
@\330N>\262
\204\277\331\332!\210\334\306\341#!\210\342\242\237!\262\343\344!!\266\203)\207" [strokes-use-strokes-buffer strokes-window-configuration strokes-buffer-name strokes-character nil current-window-configuration make-closure #[0 "\301\300!\207" [V0 set-window-configuration] 2] set-window-configuration 1 abs line-end-position window-width erase-buffer frame-height 0 insert-char 32 frame-width newline message "%s" read--potential-mouse-event down event-symbol-elements error "You must draw with the mouse" #[0 "\300\207" [nil] 1] internal--track-mouse #[0 "\300\242\204\300\304 \240\210\302\305\240\210\300\242\211:\205*\211@9\205*\306
@\307N>\206*\310
@\307N>\262
?\205\222\300\242\211:\205\\\211@9\205\\\211@\311=\206\\\306
@\307N>\206\\\312
@\307N>\206\\\310
@\307N>\262
\203\212\313\300\242!\211\203|\302\242\203|\211b\210\314
\211T\315$\210\202\200\302\305\240\210\301\316 A\301\242B\240\266\300\304 \240\210\202\207" [V0 V1 V2 strokes-character read--potential-mouse-event t click event-symbol-elements drag mouse-movement down strokes-event-closest-point subst-char-in-region 32 mouse-pixel-position] 6] buffer-name subst-char-in-region bury-buffer #[0 "\300\242\204\n\300\302 \240\210\300\242\211:\205&\211@9\205&\303
@\304N>\206&\305
@\304N>\262
?\205n\300\242\211:\205X\211@9\205X\211@\306=\206X\303
@\304N>\206X\307
@\304N>\206X\305
@\304N>\262
\203f\301\310 A\301\242B\240\210\300\302 \240\210\202\n\207" [V0 V1 read--potential-mouse-event click event-symbol-elements drag mouse-movement down mouse-pixel-position] 4] strokes-renormalize-to-grid strokes-fill-stroke strokes-eliminate-consecutive-redundancies] 13 (#$ . 16052)])
#@418 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 button 1 or button 2 and
then complete the stroke with button 3.
Optional EVENT is acceptable as the starting event of the stroke.

(fn &optional PROMPT EVENT)
(defalias 'strokes-read-complex-stroke #[512 "\211C\212\301 \302\303\"\216\304!\210\305C\305C\203<\242\211:\205)\211@9\205)\306
@\307N>\262
\204<\310\311\"\210\312 \240\210\202\313\216\314\302\315$!)\266\202)\262
)\207" [strokes-window-configuration current-window-configuration make-closure #[0 "\301\300!\207" [V0 set-window-configuration] 2] set-window-configuration nil down event-symbol-elements message "%s" read--potential-mouse-event #[0 "\302 \232\205\303ed	\304$\210eb\210\305 \207" [strokes-buffer-name strokes-character buffer-name subst-char-in-region 32 bury-buffer] 5] internal--track-mouse #[0 "\300\242\204\n\300\305 \240\210\300\242\211:\205\211@9\205\306
@\307N>\262
\203-\300\242@\307N@\310=\204\313\300\242\211:\205I\211@9\205I\311
@\307N>\206I\312
@\307N>\262
\204\244\300\242\211:\205z\211@9\205z\211@\313=\206z\311
@\307N>\206z\306
@\307N>\206z\312
@\307N>\262
\203\234\314\300\242!\211\203\222\211b\210\315
\211T\316$\210\301\317 A\301\242B\240\266\300\305 \240\210\202-\301\f\301\242B\240\210\300\242\211:\205\276\211@9\205\276\306
@\307N>\262
\204\n\300\305 \240\210\202\253\305 \211:\205\347\211@9\205\347\311
@\307N>\206\347\312
@\307N>\262
\203\313\301\211\242A\237\240\210\302\320\301\242!\240\210\321\322\302\242!!\207" [V0 V1 V2 strokes-character strokes-lift read--potential-mouse-event down event-symbol-elements mouse-3 click drag mouse-movement strokes-event-closest-point subst-char-in-region 32 mouse-pixel-position strokes-renormalize-to-grid strokes-fill-stroke strokes-eliminate-consecutive-redundancies] 6]] 12 (#$ . 18613)])
#@255 Given STROKE, execute the command which corresponds to it.
The command will be executed provided one exists for that stroke,
based on the variable `strokes-minimum-match-score'.
If no stroke matches, nothing is done and return value is nil.

(fn STROKE)
(defalias 'strokes-execute-stroke #[257 "\303
\"\211@
A\203\211	X\203\304\305\"\210\306!\207\2045\307\n!\2031\310\311\312\n\"!\205:\313 \207\314\315!\207\314\316!\210\317\207" [strokes-global-map strokes-minimum-match-score strokes-file strokes-match-stroke message "%s" command-execute file-exists-p y-or-n-p format-message "No strokes loaded.  Load `%s'? " strokes-load-user-strokes error "No strokes defined; use `strokes-global-set-stroke'" "No stroke matches; see variable `strokes-minimum-match-score'" nil] 8 (#$ . 20655)])
#@115 Read a simple stroke from the user and then execute its command.
This must be bound to a mouse event.

(fn EVENT)
(defalias 'strokes-do-stroke #[257 "\204\300\301!\210\302\303\304\"!\207" [strokes-mode t strokes-execute-stroke strokes-read-stroke nil] 5 (#$ . 21459) "e"])
#@116 Read a complex stroke from the user and then execute its command.
This must be bound to a mouse event.

(fn EVENT)
(defalias 'strokes-do-complex-stroke #[257 "\204\300\301!\210\302\303\304\"!\207" [strokes-mode t strokes-execute-stroke strokes-read-complex-stroke nil] 5 (#$ . 21743) "e"])
#@87 Displays the command which STROKE maps to, reading STROKE interactively.

(fn STROKE)
(defalias 'strokes-describe-stroke #[257 "\302
\"\211@
A\203\211	X\203\303\304\"\210\202\303\305!\210\306\307!\207" [strokes-global-map strokes-minimum-match-score strokes-match-stroke message "That stroke maps to `%s'" "That stroke is undefined" sleep-for 1] 7 (#$ . 22043) (byte-code "\300\301!C\207" [strokes-read-complex-stroke "Enter stroke to describe; end with button 3..."] 2)])
#@47 Get instruction on using the Strokes package.
(defalias 'strokes-help #[0 "r\306\307!q\210p\310 \210
\311\211\312\211\312\313 \210\314\315!\210+\211\316\317\320!!\210q\210\321 \210\322 \323!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only get-buffer-create "*Help with Strokes*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook princ substitute-command-keys "This is help for the strokes package.\n\n------------------------------------------------------------\n\n** Strokes...\n\nThe strokes package allows you to define strokes, made with\nthe mouse or other pointer device, that Emacs can interpret as\ncorresponding to commands, and then executes the commands.  It does\ncharacter recognition, so you don't have to worry about getting it\nright every time.\n\nStrokes also allows you to compose documents graphically.  You can\nfully edit documents in Chinese, Japanese, etc. based on Emacs\nstrokes.  Once you've done so, you can ASCII compress-and-encode them\nand then safely save them for later use, send letters to friends\n(using Emacs, of course).  Strokes will later decode these documents,\nextracting the strokes for editing use once again, so the editing\ncycle can continue.\n\nTo toggle strokes-mode, invoke the command\n\n> \\[strokes-mode]\n\n** Strokes for controlling the behavior of Emacs...\n\nWhen you're ready to start defining strokes, just use the command\n\n> \\[strokes-global-set-stroke]\n\nYou will see a ` *strokes*' buffer which is waiting for you to enter in\nyour stroke.  When you enter in the stroke, you draw with button 1 or\nbutton 2, and then end with button 3.  Next, you enter in the command\nwhich will be executed when that stroke is invoked.  Simple as that.\nFor now, try to define a stroke to copy a region.  This is a popular\nedit command, so type\n\n> \\[strokes-global-set-stroke]\n\nThen, in the ` *strokes*' buffer, draw the letter `C' (for `copy')\nand then, when it asks you to enter the command to map that to, type\n\n> copy-region-as-kill\n\nThat's about as hard as it gets.\nRemember: paint with button 1 or button 2 and then end with button 3.\n\nIf ever you want to know what a certain strokes maps to, then do\n\n> \\[strokes-describe-stroke]\n\nand you can enter in any arbitrary stroke.  Remember: The strokes\npackage lets you program in simple and complex (multi-lift) strokes.\nThe only difference is how you *invoke* the two.  You will most likely\nuse simple strokes, as complex strokes were developed for\nChinese/Japanese/Korean.  So the shifted middle mouse button (S-mouse-2)\nwill invoke the command `strokes-do-stroke'.\n\nIf ever you define a stroke which you don't like, then you can unset\nit with the command\n\n> \\[strokes-unset-last-stroke]\n\nYou can always get an idea of what your current strokes look like with\nthe command\n\n> \\[strokes-list-strokes]\n\nYour strokes will be displayed in alphabetical order (based on command\nnames) and the beginning of each simple stroke will be marked by a\ncolor dot.  Since you may have several simple strokes in a complex\nstroke, the dot colors are arranged in the rainbow color sequence,\n`ROYGBIV'.  If you want a listing of your strokes from most recent\ndown, then use a prefix argument:\n\n> \\[universal-argument] \\[strokes-list-strokes]\n\nYour strokes are stored as you enter them.  They get saved into the\nfile specified by the `strokes-file' variable, along with other strokes\nconfiguration variables.  You will be prompted to save them when you\nexit Emacs, or you can save them with\n\n> \\[strokes-prompt-user-save-strokes]\n\nYour strokes get loaded automatically when you enable `strokes-mode'.\nYou can also load in your user-defined strokes with\n\n> \\[strokes-load-user-strokes]\n\n** Strokes for pictographic editing...\n\nIf you'd like to create graphical files with strokes, you'll have to\nbe running a version of Emacs with XPM support.  You use the binding\nto `strokes-compose-complex-stroke' to start drawing your strokes.\nThese are just complex strokes, and thus continue drawing with mouse-1\nor mouse-2 and end with mouse-3.  Then the stroke image gets inserted\ninto the buffer.  You treat it somewhat like any other character,\nwhich you can copy, paste, delete, move, etc.  When all is done, you\nmay want to send the file, or save it.  This is done with\n\n> \\[strokes-encode-buffer]\n\nLikewise, to decode the strokes from a strokes-encoded buffer you do\n\n> \\[strokes-decode-buffer]\n\n** A few more important things...\n\no The command `strokes-do-complex-stroke' is invoked with M-mouse-2,\n  so that you can execute complex strokes (i.e. with more than one lift)\n  if preferred.\n\no Strokes are a bit computer-dependent in that they depend somewhat on\n  the speed of the computer you're working on.  This means that you\n  may have to tweak some variables.  You can read about them in the\n  commentary of `strokes.el'.  Better to just use \\[apropos] and read their\n  docstrings.  All variables/functions start with `strokes'.  The one\n  variable which many people wanted to see was\n  `strokes-use-strokes-buffer' which allows the user to use strokes\n  silently--without displaying the strokes.  All variables can be set\n  by customizing the group `strokes' via \\[customize-group]." help-mode help-print-return-message internal-temp-output-buffer-show standard-output] 6 (#$ . 22531) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias strokes-report-bug report-emacs-bug nil make-obsolete "24.1"] 4)
#@148 Non-nil if the `strokes-window-configuration' frame properties changed.
This is based on the last time `strokes-window-configuration' was updated.
(defalias 'strokes-window-configuration-changed-p #[0 "\301\302 \"\207" [strokes-window-configuration compare-window-configurations current-window-configuration] 3 (#$ . 28162)])
#@59 Ensure that `strokes-window-configuration' is up-to-date.
(defalias 'strokes-update-window-configuration #[0 "\303 \304
!\204\305
!\203\306\207\307\310!\204\"\311\312!!\203\"	\204v\212\313 \314\315\"\216\316!q\210\317\"\210\320 \210\321 \210\322\323!\210\324\323!\210\325\323!\210\326p!\210\306\327 \210\330 \211S\211\262\323Y\203h\331\332\333 S\"\210\334 \210\202Q\210eb\210\313 \335 )\262
)\207\336 \205\264\212\313 \314\337\"\216\317\"\210\320 \210\327 \210\330 \211S\211\262\323Y\203\247\331\332\333 S\"\210\334 \210\202\220\210eb\210\313 \335 )\262
)\207" [strokes-buffer-name strokes-window-configuration truncate-lines selected-window window-minibuffer-p window-dedicated-p nil called-interactively-p interactive buffer-live-p get-buffer current-window-configuration make-closure #[0 "\301\300!\207" [V0 set-window-configuration] 2] get-buffer-create set-window-buffer delete-other-windows fundamental-mode auto-save-mode 0 font-lock-mode abbrev-mode buffer-disable-undo erase-buffer frame-height insert-char 32 frame-width newline bury-buffer strokes-window-configuration-changed-p #[0 "\301\300!\207" [V0 set-window-configuration] 2]] 6 (#$ . 28495) nil])
#@62 Load user-defined strokes from file named by `strokes-file'.
(defalias 'strokes-load-user-strokes #[0 "\301!\203\302!\203\303!\207\304\305!\203\306\307!\207\310\311!\207" [strokes-file file-exists-p file-readable-p load-file called-interactively-p interactive error "Trouble loading user-defined strokes; nothing done" message "No user-defined strokes, sorry"] 2 (#$ . 29691) nil])
#@60 Save user-defined strokes to file named by `strokes-file'.
(defalias 'strokes-prompt-user-save-strokes #[0 "\212\302\303\"\216\304\305 \210\211\232\204e\306\307!\204\310\311!\203e\312\313!\210\314\315	\"\210\316\317!\210\317q\210\320 \210\321 \210eb\210\322c\210\323\324\325 \326\327\304\"#c\210\314\315	\"\210\323\330\313!\"c\210\314\315	\"\210\331ed\304#\210\332ed	#\202h\314\333!)\262
)\207" [strokes-global-map strokes-file make-closure #[0 "\302\303!\203\f\304\302\303!!\210\300\211\207" [V0 strokes-global-map get-buffer "*saved-strokes*" kill-buffer] 3] nil strokes-load-user-strokes called-interactively-p interactive yes-or-no-p "Save your strokes? " require pp message "Saving strokes in %s..." get-buffer-create "*saved-strokes*" erase-buffer emacs-lisp-mode ";;   -*- emacs-lisp -*-\n" format ";;; saved strokes for %s, as of %s\n\n" user-full-name format-time-string "%B %e, %Y" "(setq strokes-global-map\n'%s)" indent-region write-region "(no changes need to be saved)"] 7 (#$ . 30088) nil])
#@241 Toggle the use of the 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'.

(fn &optional ARG)
(defalias 'strokes-toggle-strokes-buffer #[256 "\211\203\f\301
!\302V\202?\211\207" [strokes-use-strokes-buffer prefix-numeric-value 0] 3 (#$ . 31113) "P"])
#@502 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
where each individual strokes begins.
Optional B/W-ONLY non-nil will create a mono pixmap, not intended
for trying to figure out the order of strokes, but rather for reading
the stroke as a character in some language.

(fn &optional STROKE BUFNAME B/W-ONLY)
(defalias 'strokes-xpm-for-stroke #[768 "\212\302\206\303!\304\305\306\206\307\"!!\310\311\312\313\314\315\316\257q\210\317 \210	c\210\320\211S\211\262\321Y\203C\322c\210\323\324\320\"\210\325c\210\326 \210\202(\327y\210\330\210\331c\266\330\211\211\211:\203\345@\262\242\262\243\262:\203\322\203\272	\204\272@\206x\332\321\211\333X\203\255\321\211\333X\203\245eb\210\334\\\\y\210\211T\\u\210\335\336!\210c\210\211T\262
\202\200\210\211T\262
\202y\210A\262\330\262\210\202\333eb\210\337\\y\210\333\\u\210\340``T\324\341$\210\202\333\342!\203\333\310\262A\262\330\262
\202R\266\343\344!\205
\345\303!\210eb\210\346\347\350 \351\310\352\353%\354 \"\266\204)\207" [strokes-last-stroke strokes-xpm-header get-buffer-create " *strokes-xpm*" strokes-eliminate-consecutive-redundancies strokes-fill-stroke strokes-renormalize-to-grid 31 t 82 79 89 71 66 80 erase-buffer 33 0 34 insert-char 32 "\"," newline -1 nil "}\n" 46 2 15 delete-char 1 16 subst-char-in-region 42 strokes-lift-p called-interactively-p interactive pop-to-buffer put-image create-image buffer-string xpm :ascent 100 line-end-position] 17 (#$ . 31522) nil])
#@293 Pop up a buffer containing an alphabetical listing of strokes in STROKES-MAP.
With CHRONOLOGICAL prefix arg (\[universal-argument]) list strokes chronologically
by command name.
If STROKES-MAP is not given, `strokes-global-map' will be used instead.

(fn &optional CHRONOLOGICAL STROKES-MAP)
(defalias 'strokes-list-strokes #[512 "\211\206\f\206\f\303 \210\262

\204\304\305!\306\"\262
\307 \310\311!q\210\312\313 \210\314\315\261\210
\312
:\203\201
@\262
\211@
A9\203E\316A!\202I\317A!\320\321\"\210\322\323!\210\324\325\326\"\210\327 \210\211c\210\327 \210\326u\210\330\331r\321q\210\332 )\333\334\335\336\337\312\340\"BC%!\266
A\262\202-m\204\213\341`Td\"\210\266\342\311\312\"\210\343\302!\210\344\n!\345
\346\347\312\350\351\352	D\257#\210\211\262
eb\207" [strokes-global-map buffer-read-only view-mode-map strokes-load-user-strokes sort copy-sequence strokes-alphabetic-lessp current-window-configuration get-buffer-create "*Strokes List*" nil erase-buffer "Command                                     Stroke\n" "-------                                     ------" symbol-name prin1-to-string strokes-xpm-for-stroke " *strokes-xpm*" newline 2 insert-char 32 45 beginning-of-line insert-image create-image buffer-string xpm t :color-symbols "foreground" frame-parameter foreground-color kill-region view-buffer make-local-variable copy-keymap define-key "q" lambda (interactive) (View-quit) set-window-configuration] 17 (#$ . 33208) "P"])
#@101 Return t if STROKE1's command name precedes STROKE2's in lexicographic order.

(fn STROKE1 STROKE2)
(defalias 'strokes-alphabetic-lessp #[514 "
A
A\231\207" [] 4 (#$ . 34682)])
(defvar strokes-mode-map (byte-code "\300 \301
\302\303#\210\301
\304\305#\210\207" [make-sparse-keymap define-key [(shift down-mouse-2)] strokes-do-stroke [(meta down-mouse-2)] strokes-do-complex-stroke] 5))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable strokes-mode funcall function #[0 "\300\207" [nil] 1 ""] "Non-nil if Strokes mode is enabled.\nSee the `strokes-mode' command\nfor a description of this minor mode.\nSetting this variable directly does not take effect;\neither customize it (see the info node `Easy Customization')\nor call the function `strokes-mode'." :set custom-set-minor-mode :initialize custom-initialize-default :type boolean] 10)
#@1117 Toggle Strokes mode, a global minor mode.

This is a minor mode.  If called interactively, toggle the `Strokes
mode' mode.  If the prefix argument is positive, enable the mode, and
if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the
mode if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer,
evaluate `(default-value \='strokes-mode)'.

The mode's hook is called both when the mode is enabled and when it is
disabled.

\<strokes-mode-map>
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
\[strokes-compose-complex-stroke], which draws strokes and inserts them.
Encode/decode your strokes with \[strokes-encode-buffer],
\[strokes-decode-buffer].

\{strokes-mode-map}

(fn &optional ARG)
(defalias 'strokes-mode #[256 "\305 \306\301\307=\203\310\301!?\202!\247\203 \311W\203 \312\202!\313\"\210\314\300!\2038\315\301\"\310\301!\2038\301B\316 \204D\317\320!\210\202v	\203e\321\n!\203U\204U\322 \210\323\324\325\"\210\323\326\327\"\210\327 \210\202v\330\f!\203q\331\330\f!!\210\332\326\327\"\210\333\334\310\301!\203\202\335\202\203\336\"\210\337\340!\203\253\341\301!\210\305 \203\233\211\305 \232\203\253\342\343\310\301!\203\247\344\202\250\345\346#\210\210\347 \210\310\301!\207" [global-minor-modes strokes-mode strokes-file strokes-global-map strokes-buffer-name current-message set-default toggle default-value 1 nil t boundp delq display-mouse-p error "Can't use Strokes without a mouse" file-exists-p strokes-load-user-strokes add-hook kill-emacs-query-functions strokes-prompt-user-save-strokes select-frame-hook strokes-update-window-configuration get-buffer kill-buffer remove-hook run-hooks strokes-mode-hook strokes-mode-on-hook strokes-mode-off-hook called-interactively-p any customize-mark-as-set message "Strokes mode %sabled%s" "en" "dis" "" force-mode-line-update] 6 (#$ . 35575) (byte-code "\203\n\301!\202\302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)])
(defvar strokes-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\313\314\300!\205#\310\211%\210\315\316\317\320\321\322%\210\303\323\324\325#\207" [strokes-mode-map strokes-mode-hook variable-documentation put "Hook run after entering or leaving `strokes-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode strokes-mode strokes-lighter boundp custom-declare-face strokes-char ((t (:background "lightgray"))) "Face for strokes characters." :version "21.1" strokes char-table-extra-slots 0] 6)
#@55 The table which stores values for the character keys.
(defconst strokes-char-table (byte-code "\300\301!\211\302\303I\210\211\304\305I\210\211\306\307I\210\211\310\311I\210\211\312\313I\210\211\314\315I\210\211\316\317I\210\211\320\321I\210\211\322\323I\210\211\324\325I\210\211\326\327I\210\211\330\331I\210\211\332\333I\210\211\334\335I\210\211\336\337I\210\211\340\341I\210\211\342\343I\210\211\344\345I\210\211\346\347I\210\211\350\351I\210\211\352\353I\210\211\354\355I\210\211\356\357I\210\211\360\361I\210\211\362\363I\210\211\364\365I\210\211\366\367I\210\211\370\371I\210\211\372\373I\210\211\374\375I\210\211\376\377I\210\211\201@\201AI\210\211\201B\201CI\210\211\201D\201EI\210\211\201F\201GI\210\211\201H\201II\210\211\201J\201KI\210\211\201L\201MI\210\211\201N\201OI\210\211\201P\201QI\210\211\201R\201SI\210\211\201T\201UI\210\211\201V\201WI\210\211\201X\201YI\210\211\201Z\201[I\210\211\201\\\201]I\210\211\201^\201_I\210\211\201`\201aI\210\211\201b\302I\210\211\201c\304I\210\211\201d\306I\210\211\201e\310I\210\211\201f\312I\210\211\201g\314I\210\211\201h\316I\210\211\201i\320I\210\211\201j\322I\210\211\201k\324I\210\211\201l\201mI\210\211\201n\201oI\210\211\201p\201qI\210\211\201r\201sI\210\207" [make-char-table strokes 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 56 8 57 9 97 10 98 11 99 12 100 13 101 14 102 15 103 16 104 17 105 18 106 19 107 20 108 21 109 22 110 23 111 24 112 25 113 26 114 27 115 28 116 29 117 30 118 31 119 32 120 33 121 34 122 35 65 36 66 37 67 38 68 39 69 40 70 41 71 42 72 43 73 44 74 45 75 46 76 47 77 78 79 80 81 82 83 84 85 86 87 58 88 59 89 60 90 61] 4) (#$ . 38629))
#@76 Character vector for fast lookup of base-64 encoding of numbers in [0,61].
(defconst strokes-base64-chars (byte-code "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376&>\207" [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" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z" "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z"] 63) (#$ . 40302))
#@63 Non-nil if CHAR represents an `on' bit in the XPM.

(fn CHAR)
(defalias 'strokes-xpm-char-on-p #[257 "\211\300=\207" [42] 3 (#$ . 40961)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-xpm-char-on-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@72 Non-nil if CHAR represents an `on' or `off' bit in the XPM.

(fn CHAR)
(defalias 'strokes-xpm-char-bit-p #[257 "\211\300=\206	\211\301=\207" [32 42] 3 (#$ . 41253)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-xpm-char-bit-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@76 Given some LENGTH in [0,62) do a fast lookup of its encoding.

(fn LENGTH)
(defalias 'strokes-xpm-encode-length-as-string #[257 "
H\207" [strokes-base64-chars] 3 (#$ . 41574)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-xpm-encode-length-as-string speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@94 Given a CHARACTER, do a fast lookup to find its corresponding integer value.

(fn CHARACTER)
(defalias 'strokes-xpm-decode-char #[257 "
H\207" [strokes-char-table] 3 (#$ . 41919)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put strokes-xpm-decode-char speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@141 Convert XPM in XPM-BUFFER to compressed string representing the stroke.
XPM-BUFFER defaults to " *strokes-xpm*".

(fn &optional XPM-BUFFER)
(defalias 'strokes-xpm-to-compressed-string #[256 "r\211\206\301\211\262q\210eb\210\302\303!\210\304u\210\305\306\307\310\211f\211\311=\204\271\306U\203G\211\211\312=\2061\211\313=\262
\203A\314\262\211\211\313=\262
\262\314u\210\202\262\315U\203l=\205Z\306
H\262
\315
H\262
Q\262
\262\306\262\202\262\211\211\312=\206v\211\313=\262
\203\257

\211\313=\262
=\203\220T\262\314u\210\202\262=\205\235\306
H\262

H\262
Q\262\306\262
\262\202\262\314u\210\310f\262
\202\306V\205\323=\205\314\306
H\262

H\262
P\316Q\266\205)\207" [strokes-base64-chars " *strokes-xpm*" search-forward "/* pixels */" 2 "+/" 0 t nil 125 32 42 1 61 "/"] 11 (#$ . 42257)])
#@216 Decode stroke strings in BUFFER and display their corresponding glyphs.
Optional BUFFER defaults to the current buffer.
Optional FORCE non-nil will ignore the buffer's read-only status.

(fn &optional BUFFER FORCE)
(defalias 'strokes-decode-buffer #[512 "r\302\206p!\211\262q\210\203\"\211\204\"	\204\"\303\304\305\"!\205y\306\307\310\"\210eb\210\311\211rq\210\312\313\311\306\311$\205I\314\315!\262\316\225b\210\317\320!\210\306)\203r\321\322\"\210\323r\322q\210\324 )\325\306#\262
\326
\327\320\330\331\211\332\n&\"\210\202.\266\307\333\"))\207" [buffer-read-only inhibit-read-only get-buffer y-or-n-p format "Buffer %s is read-only.  Strokify anyway? " t message "Strokifying %s..." nil re-search-forward "\\+/\\(\\w+\\)/" match-string 1 0 replace-match " " strokes-xpm-for-compressed-string " *strokes-xpm*" create-image buffer-string xpm insert-image propertize type stroke-glyph data "Strokifying %s...done"] 14 (#$ . 43102) nil])
#@213 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.

(fn &optional BUFFER FORCE)
(defalias 'strokes-encode-buffer #[512 "r
\206p\211\262q\210\203 \211\204 	\204 \302\303\304\"!\205}\305\306\"\210\307\310\211o\2035\311`\312\"\204?\313`\312\"\211\262\203u\311`\312\"\314=\203*
b\210\315 \262\311\316\"\262
\317\311`\320\"\321\261\210\322\323!\210\324`\312\325\326\327\314\316\310\257#\210\202*\305\330\")\266\203)\207" [buffer-read-only inhibit-read-only y-or-n-p format "Buffer %s is read-only.  Encode anyway? " message "Encoding strokes in %s..." t nil get-text-property type next-single-property-change stroke-glyph point-marker display "+/" data 47 delete-char 1 add-text-properties stroke-string face strokes-char "Encoding strokes in %s...done"] 16 (#$ . 44070) nil])
#@178 Convert the stroke represented by COMPRESSED-STRING into an XPM.
Store XPM in buffer BUFNAME if supplied (default is " *strokes-xpm*")

(fn COMPRESSED-STRING &optional BUFNAME)
(defalias 'strokes-xpm-for-compressed-string #[513 "\211\204\302\262
r\303
!q\210\304 \210
c\210eb\210\305m\2049\306
\203$\307\202%\310\305f
H\262
\"\210\311\312!\210\211?\262
\202eb\210\313\211S\211\262\314Y\203S\315c\210\313u\210\316c\210\202=\210eb\210	c\262
)\207" [strokes-char-table strokes-xpm-header " *strokes-xpm*" get-buffer-create erase-buffer nil insert-char 42 32 delete-char 1 33 0 34 "\",\n"] 8 (#$ . 45008)])
#@69 Read a complex stroke and insert its glyph into the current buffer.
(defalias 'strokes-compose-complex-stroke #[0 "\301\302 \210\303\304\305\306#\210\307\305!c\210\310 \210\304u)\207" [strokes-grid-resolution 33 strokes-read-complex-stroke strokes-xpm-for-stroke nil " *strokes-xpm*" t strokes-xpm-to-compressed-string strokes-decode-buffer] 4 (#$ . 45628) "*"])
#@29 Unload the Strokes library.
(defalias 'strokes-unload-function #[0 "\300\301!\210\302\207" [strokes-mode -1 nil] 2 (#$ . 45998)])
(byte-code "\300\301!\210\302\303!\207" [run-hooks strokes-load-hook provide strokes] 2)