1;;; gametree.el --- manage game analysis trees in Emacs
2
3;; Copyright (C) 1997, 1999, 2001, 2002, 2003, 2004,
4;;   2005, 2006, 2007 Free Software Foundation, Inc.
5
6;; Author: Ian T Zimmerman <itz@rahul.net>
7;; Created: Wed Dec 10 07:41:46 PST 1997
8;; Keywords: games
9
10;; This file is part of GNU Emacs.
11
12;; GNU Emacs is free software; you can redistribute it and/or modify
13;; it under the terms of the GNU General Public License as published by
14;; the Free Software Foundation; either version 2, or (at your option)
15;; any later version.
16
17;; GNU Emacs is distributed in the hope that it will be useful,
18;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20;; GNU General Public License for more details.
21
22;; You should have received a copy of the GNU General Public License
23;; along with GNU Emacs; see the file COPYING.  If not, write to the
24;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25;; Boston, MA 02110-1301, USA.
26
27;;; Commentary:
28
29;;  This little hack has enabled me to keep track of my email chess
30;;  games in Emacs.  For a long time I dreamt about writing a real,
31;;  graphical tree editor; but, then the idea struck me, why do it
32;;  graphically, when it can be done in Emacs? :-)  And in fact Emacs
33;;  almost had what I needed out of the box, namely the powerful
34;;  Outline mode.  This code is built entirely on Outline mode, it
35;;  only adds two commands that I found indispensable when dealing
36;;  with the special kind of trees that analysis trees comprise.
37
38;;  The built-in documentation should be enough to explain the use,
39;;  along with the following example (yes, this is a real game).
40
41;;  *** 23. f4 ef 24. Nf3 Rf3 -/+
42;;  25. Rf3 Qh2 26. Kh1 Qh1 27. Ke2 Qg2 -+
43;;  ******* 25. gf3 Nce3 26. Qe2 Nf1 -/+
44;;  27. Qe5 Ne5 28. Kf1 Nf3 -/+
45;;  27. Kf1 Nh2 28. Kf2 Ng4 29. fg4 Rf8 30. Ke1 Qg3 31. Kd1 Rf2 -+
46
47;;  Place the preceding in a scratch buffer, load this code, and do
48;;  M-x gametree-mode.  Now place the cursor just after the `Nf3' and
49;;  before the `Rf3' on the first line, and do C-c C-j.  The result is
50
51;;  *** 23. f4 ef 24. Nf3
52;;  ****** 24: Rf3 -/+
53;;  25. Rf3 Qh2 26. Kh1 Qh1 27. Ke2 Qg2 -+
54;;  ******* 25. gf3 Nce3 26. Qe2 Nf1 -/+
55;;  27. Qe5 Ne5 28. Kf1 Nf3 -/+
56;;  27. Kf1 Nh2 28. Kf2 Ng4 29. fg4 Rf8 30. Ke1 Qg3 31. Kd1 Rf2 -+
57
58;;  Now you can add another subvariation on Black's 24th move: with
59;;  the cursor still on the first line, do C-c C-v, and voila
60
61;;  *** 23. f4 ef 24. Nf3
62;;  24:
63;;  ****** 24: Rf3 -/+
64;;  25. Rf3 Qh2 26. Kh1 Qh1 27. Ke2 Qg2 -+
65;;  ******* 25. gf3 Nce3 26. Qe2 Nf1 -/+
66;;  27. Qe5 Ne5 28. Kf1 Nf3 -/+
67;;  27. Kf1 Nh2 28. Kf2 Ng4 29. fg4 Rf8 30. Ke1 Qg3 31. Kd1 Rf2 -+
68
69;;  and the cursor is positioned on the new line just after the move
70;;  number, so you can start typing the new analysis.  That's it,
71;;  quite simple.
72
73;;  As of version 1.1, a simple score reducer has been implemented.
74;;  As you type in leaf variations, you can add a numerical score tag
75;;  to them with C-c ; . Then, with the cursor on a variation higher
76;;  up in the tree, you can do C-c ^ and the program will compute the
77;;  reduced score of the internal variation based on the scores of its
78;;  children (which are recursively computed).  You can use any range
79;;  of numbers you wish as scores, maybe -1000 to 1000 or 0 to 100,
80;;  all that matters to the program is that higher means better for
81;;  White, lower means better for Black.
82
83;;; Code:
84
85(require 'derived)
86(require 'outline)
87
88;;;; Configuration variables
89
90(defgroup gametree nil
91  "Manage game analysis trees in Emacs."
92  :prefix "gametree-"
93  :group 'games
94  :version "20.3")
95
96(defcustom gametree-half-ply-regexp (regexp-quote ":")
97  "*Matches ends of numbers of moves by the \"second\" player.
98For instance, it is an almost universal convention in chess to postfix
99numbers of moves by Black (if considered in isolation) by the ellipsis
100\"...\".  This is NOT a good choice for this program, though, because it
101conflicts with the use of ellipsis by Outline mode to denote collapsed
102subtrees.  The author uses \":\" because it agrees nicely with a set of
103LaTeX macros he uses for typesetting annotated games."
104  :type 'regexp
105  :group 'gametree)
106
107(defcustom gametree-full-ply-regexp (regexp-quote ".")
108  "*Matches ends of numbers of moves by the \"first\" player.
109For instance, it is an almost universal convention in chess to postfix
110numbers of moves by White (if considered in isolation) by the dot \".\"."
111  :type 'regexp
112  :group 'gametree)
113
114(defcustom gametree-half-ply-format "%d:"
115  "*Output format for move numbers of moves by the \"second\" player.
116Has to contain \"%d\" to output the actual number."
117  :type 'string
118  :group 'gametree)
119
120(defcustom gametree-full-ply-format "%d."
121  "*Output format for move numbers of moves by the \"first\" player.
122Has to contain \"%d\" to output the actual number."
123  :type 'string
124  :group 'gametree)
125
126(defcustom gametree-make-heading-function
127  (function (lambda (level)
128              (insert (make-string level ?*))))
129  "A function of one numeric argument, LEVEL, to insert a heading at point.
130You should change this if you change `outline-regexp'."
131  :type 'function
132  :group 'gametree)
133
134(defvar gametree-local-layout nil
135  "A list encoding the layout (i.e. the show or hide state) of the file.
136If Emacs notices a local variable specification of this variable in
137the first line of the buffer while saving the buffer to the visited
138file, the local value will be saved there and restored the next time
139the file is visited (subject to the usual restriction via
140`enable-local-variables'), and the layout will be set accordingly.")
141
142(defcustom gametree-score-opener "{score="
143  "*The string which opens a score tag, and precedes the actual score."
144  :type 'string
145  :group 'gametree)
146
147(defcustom gametree-score-manual-flag "!"
148  "*String marking the line as manually (as opposed to automatically) scored."
149  :type 'string
150  :group 'gametree)
151
152(defcustom gametree-score-closer "}"
153  "*The string which closes a score tag, and follows the actual score."
154  :type 'string
155  :group 'gametree)
156
157(defcustom gametree-score-regexp
158  (concat "[^\n\^M]*\\("
159          (regexp-quote gametree-score-opener)
160          "[ 	]*\\("
161          (regexp-quote gametree-score-manual-flag)
162          "[ 	]*\\)?\\([-+]?[0-9]+\\)"
163          (regexp-quote gametree-score-closer)
164          "[ 	]*\\)[\n\^M]")
165  "*Regular expression matching lines that guide the program in scoring.
166Its third parenthetical group should match the actual score.  Its
167first parenthetical group should match the entire score tag.  Its
168second parenthetical group should be an optional flag that marks the
169line as *manually* (as opposed to automatically) scored, which
170prevents the program from recursively applying the scoring algorithm
171on the subtree headed by the marked line, and makes it use the manual
172score instead."
173  :type 'regexp
174  :group 'gametree)
175
176(defcustom gametree-default-score 0
177  "*Score to assume for branches lacking score tags."
178  :type 'integer
179  :group 'gametree)
180
181;;;; Helper functions
182
183(defun gametree-prettify-heading ()
184  "Insert/delete space between leading asterisks and heading text.
185If the current variation is an internal node (i.e. starts with one or
186more asterisks), ensure there's at least one space between the
187asterisks and the text.  If on the other hand this is a leaf, there
188should be no leading white space."
189  (save-excursion
190    (beginning-of-line 1)
191    (if (re-search-forward (concat "\\=" outline-regexp) nil t)
192        (if (not (looking-at "[ \t]+")) (insert " "))
193      (delete-char (save-excursion (skip-chars-forward " \t"))))
194    (if (re-search-forward (concat "\\=[ \t]*[1-9][0-9]*\\("
195                                   gametree-full-ply-regexp "\\|"
196                                   gametree-half-ply-regexp "\\)") nil t)
197        (if (not (looking-at "[ \t]+")) (insert " ")
198          (delete-char (1- (save-excursion (skip-chars-forward  " \t"))))))))
199
200(defun gametree-looking-at-ply ()
201  "Read and return the number of the ply under point."
202  (if (eobp) 0
203    (let ((boundary (concat "[ \t]*\\([1-9][0-9]*\\)\\("
204                            gametree-full-ply-regexp "\\|"
205                            gametree-half-ply-regexp "\\)"))
206          (limit (save-excursion (beginning-of-line 1) (point))))
207      (if (looking-at boundary)
208          (+ (* 2 (string-to-number (match-string 1)))
209             (if (string-match gametree-half-ply-regexp (match-string 2)) 1 0))
210        (save-excursion
211          (re-search-backward boundary limit)
212          (skip-chars-backward "0123456789")
213          (1+ (* 2 (string-to-number
214                    (buffer-substring (point) (match-end 1))))))))))
215
216(defun gametree-current-branch-ply ()
217  "Return the ply number of the first move of the current variation."
218  (save-excursion
219    (beginning-of-line 1)
220    (re-search-forward (concat "\\=" outline-regexp) nil t)
221    (gametree-looking-at-ply)))
222
223(defsubst gametree-forward-line ()
224  (re-search-forward "[\n\^M]" nil 'move))
225
226(defun gametree-current-branch-depth ()
227  "Return the depth of the current variation in the analysis tree.
228This value is simply the outline heading level of the current line."
229  (save-excursion
230    (beginning-of-line 1)
231    (if (looking-at outline-regexp)
232        (outline-level) 0)))
233
234(defun gametree-transpose-following-leaves ()
235  "Move the current leaf variation behind all others on the same level."
236  (let ((following-leaves
237         (save-excursion
238           (gametree-forward-line)
239           (let ((p (point)))
240             (while (and (not (eobp))
241                         (= 0 (gametree-current-branch-depth)))
242               (gametree-forward-line))
243             (prog1 (buffer-substring p (point))
244               (delete-region p (point)))))))
245    (save-excursion
246      (beginning-of-line 1)
247      (insert following-leaves))))
248
249
250;;;; Functions related to the task of saving and restoring current
251;;;; outline layout
252
253(defsubst gametree-show-children-and-entry ()
254  (show-children)
255  (show-entry))
256
257(defun gametree-entry-shown-p ()
258  (save-excursion
259    (forward-line 1)
260    (and (bolp) (not (eobp)) (not (looking-at outline-regexp)))))
261
262(defun gametree-children-shown-p ()
263  (save-excursion
264    (condition-case nil
265        (let ((depth (gametree-current-branch-depth)))
266          (outline-next-visible-heading 1)
267          (< depth (gametree-current-branch-depth)))
268      (error nil))))
269
270(defun gametree-current-layout (depth &optional top-level)
271  (let ((layout nil) (first-time t))
272    (while (save-excursion
273             (condition-case nil
274                 (progn
275                   (or (and first-time top-level
276                            (bolp) (looking-at outline-regexp))
277                       (setq first-time nil)
278                       (outline-next-visible-heading 1))
279                   (< depth (gametree-current-branch-depth)))
280               (error nil)))
281      (if (not first-time)
282          (outline-next-visible-heading 1))
283      (setq first-time nil)
284      (if (not (gametree-children-shown-p))
285          (setq layout
286                (nconc layout
287                       (if (gametree-entry-shown-p)
288                           (list 'show-entry)
289                         (list nil))))
290        (setq layout (nconc layout (if (gametree-entry-shown-p)
291                                       (list 'gametree-show-children-and-entry)
292                                     (list 'show-children))))
293        (let ((sub-layout
294               (gametree-current-layout (gametree-current-branch-depth))))
295          (setq layout (nconc layout (list sub-layout))))))
296    layout))
297
298(defun gametree-save-layout ()
299  (save-excursion
300    (goto-char (point-min))
301    (setq gametree-local-layout (gametree-current-layout 0 t))))
302
303(defun gametree-apply-layout (layout depth &optional top-level)
304  (let ((first-time t))
305    (while (and layout
306                (save-excursion
307                  (condition-case nil
308                      (progn
309                        (or (and first-time top-level
310                                 (bolp) (looking-at outline-regexp))
311                            (setq first-time nil)
312                            (outline-next-visible-heading 1))
313                        (< depth (gametree-current-branch-depth)))
314                    (error nil))))
315      (if (not first-time)
316          (outline-next-visible-heading 1))
317      (setq first-time nil)
318      (hide-subtree)
319      (if (nth 0 layout)
320          (funcall (nth 0 layout)))
321      (if (not (and (nth 1 layout) (listp (nth 1 layout))))
322          (setq layout (cdr layout))
323        (gametree-apply-layout (nth 1 layout)
324                               (gametree-current-branch-depth))
325        (setq layout (cdr (cdr layout)))))))
326
327(defun gametree-restore-layout ()
328  (save-excursion
329    (goto-char (point-min))
330    (gametree-apply-layout gametree-local-layout 0 t)))
331
332(defun gametree-hack-file-layout ()
333  (save-excursion
334    (goto-char (point-min))
335    (if (looking-at "[^\n]*-\*-[^\n]*gametree-local-layout: \\([^;\n]*\\);")
336        (progn
337          (goto-char (match-beginning 1))
338          (delete-region (point) (match-end 1))
339          (let ((standard-output (current-buffer)))
340            (princ gametree-local-layout))))))
341
342
343;;;; Scoring functions
344
345(defun gametree-current-branch-score ()
346  "Return score of current variation according to its score tag.
347When no score tag is present, use the value of `gametree-default-score'."
348  (if (looking-at gametree-score-regexp)
349      (string-to-number (match-string 3))
350    gametree-default-score))
351
352(defun gametree-compute-reduced-score ()
353  "Return current internal node score computed recursively from subnodes.
354Subnodes which have been manually scored are honored."
355  (if (or
356       (= 0 (gametree-current-branch-depth))
357       (save-excursion (gametree-forward-line) (eobp))
358       (and (looking-at gametree-score-regexp)
359            (not (null (match-string 2)))))
360      (gametree-current-branch-score)
361    (let ((depth (gametree-current-branch-depth)))
362      (save-excursion
363        (gametree-forward-line)
364        ;; the case of a leaf node has already been handled, so here I
365        ;; know I am on the 1st line of the current subtree.  This can
366        ;; be either a leaf child, or a subheading.
367        (let ((running gametree-default-score)
368              (minmax
369               (if (= 0 (mod (gametree-current-branch-ply) 2))
370                   'max 'min)))
371          (while (and (not (eobp))
372                      (= 0 (gametree-current-branch-depth))) ;handle leaves
373            (setq running (funcall minmax running
374                                   (gametree-current-branch-score)))
375            (gametree-forward-line))
376          (let ((done (and (not (eobp))
377                           (< depth (gametree-current-branch-depth)))))
378            (while (not done)           ;handle subheadings
379              (setq running (funcall minmax running
380                                     (gametree-compute-reduced-score)))
381              (setq done (condition-case nil
382                             (outline-forward-same-level 1)
383                           (error nil)))))
384          running)))))
385
386;;;; Commands
387
388(defun gametree-insert-new-leaf (&optional at-depth)
389  "Start a new leaf variation under the current branching point.
390The new variation can later be split to be a branching point itself,
391with \\[gametree-break-line-here].  If the point is currently on a
392leaf variation, this command won't work; use \\[gametree-break-line-here]
393on the current line first.
394
395With a numeric arg AT-DEPTH, first go up the tree until a node of
396depth AT-DEPTH or smaller is found."
397  (interactive "*P")
398  (if (zerop (gametree-current-branch-depth))
399      (outline-up-heading 0))
400  (if at-depth
401      (while (> (gametree-current-branch-depth)
402                (prefix-numeric-value at-depth))
403        (outline-up-heading 1)))
404  (beginning-of-line 1)
405  (let ((parent-depth (gametree-current-branch-depth)))
406    (show-entry)
407    (condition-case nil
408        (outline-next-visible-heading 1)
409      (error
410       (goto-char (point-max))
411       (if (not (bolp)) (insert "\n"))))
412    (let ((starting-plys
413           (if (> (gametree-current-branch-depth) parent-depth)
414               (gametree-current-branch-ply)
415             (save-excursion (forward-line -1)
416                             (gametree-current-branch-ply)))))
417      (goto-char (1- (point)))
418      (insert "\n")
419      (insert (format (if (= 0 (mod starting-plys 2))
420                          gametree-full-ply-format
421                        gametree-half-ply-format)
422                      (/ starting-plys 2))))))
423
424(defun gametree-break-line-here (&optional at-move)
425  "Split the variation node at the point position.
426This command works whether the current variation node is a leaf, or is
427already branching at its end.  The new node is created at a level that
428reflects the number of game plys between the beginning of the current
429variation and the breaking point.
430
431With a numerical argument AT-MOVE, split the variation before
432White's AT-MOVEth move, or Black's if negative.  The last option will
433only work of Black's moves are explicitly numbered, for instance
434`1. e4 1: e5'."
435  (interactive "*P")
436  (if at-move (progn
437          (end-of-line 1)
438          (let ((limit (point)))
439            (beginning-of-line 1)
440            (re-search-forward
441             (concat
442              (regexp-quote
443               (int-to-string (abs (prefix-numeric-value at-move))))
444              (if (> at-move 0) gametree-full-ply-regexp
445                gametree-half-ply-regexp)) limit))
446          (goto-char (match-beginning 0))))
447  (gametree-transpose-following-leaves)
448  (let* ((pt (set-marker (make-marker) (point)))
449         (plys (gametree-current-branch-ply))
450         (depth (gametree-current-branch-depth))
451         (old-depth depth))
452    (if (= depth 0)
453        (progn
454          (save-excursion
455            (outline-previous-visible-heading 1)
456            (setq depth
457                  (let ((old-branch-ply
458                         (condition-case nil
459                             (gametree-current-branch-ply)
460                           (error 0))))
461                    (if (zerop old-branch-ply)
462                        (1+ (gametree-current-branch-depth))
463                      (+ (gametree-current-branch-depth)
464                         (- plys old-branch-ply))))))
465          (save-excursion
466            (beginning-of-line 1)
467            (funcall gametree-make-heading-function depth)
468            (gametree-prettify-heading))))
469    (save-excursion
470      (if (not (looking-at (concat "[ \t]*[1-9][0-9]*\\("
471                                   gametree-full-ply-regexp "\\|"
472                                   gametree-half-ply-regexp "\\)")))
473          (progn
474            (insert (format (if (= 0 (mod (gametree-looking-at-ply) 2))
475                                gametree-full-ply-format
476                              gametree-half-ply-format)
477                            (/ (gametree-looking-at-ply) 2)))
478            (gametree-prettify-heading)
479            (beginning-of-line 1)))
480      (goto-char pt)
481      (insert "\n")
482      (if (not (= 0 old-depth))
483          (funcall gametree-make-heading-function
484                   (+ depth (- (gametree-current-branch-ply) plys))))
485      (gametree-prettify-heading))))
486
487(defun gametree-merge-line ()
488  "Merges a variation with its only child.
489Does *not* check if the variation has in fact a unique child; users beware."
490  (interactive "*")
491  (if (zerop (gametree-current-branch-depth))
492      (outline-up-heading 0))
493  (if (looking-at gametree-score-regexp)
494      (delete-region (match-beginning 1) (match-end 1)))
495  (end-of-line 1)
496  (let ((prev-depth (save-excursion (forward-line 1)
497                                    (gametree-current-branch-depth))))
498    (delete-char (1+ prev-depth))
499    (if (zerop prev-depth)
500        (save-excursion
501          (beginning-of-line 1)
502          (delete-char (gametree-current-branch-depth))
503          (gametree-prettify-heading)))))
504
505(defun gametree-insert-score (score &optional auto)
506  "Insert a score tag with value SCORE at the end of the current line.
507If this line already has a score tag, just jump to it and alter it.
508When called from a program, optional AUTO flag tells if the score is
509being entered automatically (and thus should lack the manual mark)."
510  (interactive "*P")
511  (beginning-of-line 1)
512  (if (looking-at gametree-score-regexp)
513      (progn
514        (goto-char (match-beginning 3))
515        (if (and auto (not (null (match-string 2))))
516            (delete-region (match-beginning 2) (match-end 2)))
517        (if (not (null score))
518            (delete-region (match-beginning 3) (match-end 3)))
519        (if (and (not auto) (null (match-string 2)))
520            (insert gametree-score-manual-flag)))
521    (end-of-line 1)
522    (if (= 0 (save-excursion (skip-chars-backward " \t")))
523        (insert " "))
524    (insert gametree-score-opener)
525    (if (not auto) (insert gametree-score-manual-flag))
526    (save-excursion (insert gametree-score-closer)))
527  (if (not (null score))
528      (save-excursion
529        (insert (int-to-string (prefix-numeric-value score))))))
530
531(defun gametree-compute-and-insert-score ()
532  "Compute current node score, maybe recursively from subnodes. Insert it.
533Subnodes which have been manually scored are honored."
534  (interactive "*")
535  (let ((auto (not (and (looking-at gametree-score-regexp)
536                        (not (null (match-string 2))))))
537        (score (gametree-compute-reduced-score)))
538    (gametree-insert-score score auto)))
539
540
541(defun gametree-layout-to-register (register)
542  "Store current tree layout in register REGISTER.
543Use \\[gametree-apply-register-layout] to restore that configuration.
544Argument is a character, naming the register."
545  (interactive "cLayout to register: ")
546  (save-excursion
547    (goto-char (point-min))
548    (set-register register
549                  (gametree-current-layout 0 t))))
550
551(defun gametree-apply-register-layout (char)
552  "Return to a tree layout stored in a register.
553Argument is a character, naming the register."
554  (interactive "*cApply layout from register: ")
555  (save-excursion
556    (goto-char (point-min))
557    (gametree-apply-layout (get-register char) 0 t)))
558
559(defun gametree-save-and-hack-layout ()
560  "Save the current tree layout and hack the file local variable spec.
561This function saves the current layout in `gametree-local-layout' and,
562if a local file varible specification for this variable exists in the
563buffer, it is replaced by the new value.  See the documentation for
564`gametree-local-layout' for more information."
565  (interactive)
566  (gametree-save-layout)
567  (let ((inhibit-read-only t))
568    (gametree-hack-file-layout))
569  nil)
570
571(define-derived-mode gametree-mode outline-mode "GameTree"
572  "Major mode for managing game analysis trees.
573Useful to postal and email chess (and, it is hoped, also checkers, go,
574shogi, etc.) players, it is a slightly modified version of Outline mode.
575
576\\{gametree-mode-map}"
577  (auto-fill-mode 0)
578  (make-local-variable 'write-contents-hooks)
579  (add-hook 'write-contents-hooks 'gametree-save-and-hack-layout))
580
581;;;; Key bindings
582
583(define-key gametree-mode-map "\C-c\C-j" 'gametree-break-line-here)
584(define-key gametree-mode-map "\C-c\C-v" 'gametree-insert-new-leaf)
585(define-key gametree-mode-map "\C-c\C-m" 'gametree-merge-line)
586(define-key gametree-mode-map "\C-c\C-r " 'gametree-layout-to-register)
587(define-key gametree-mode-map "\C-c\C-r/" 'gametree-layout-to-register)
588(define-key gametree-mode-map "\C-c\C-rj" 'gametree-apply-register-layout)
589(define-key gametree-mode-map "\C-c\C-y" 'gametree-save-and-hack-layout)
590(define-key gametree-mode-map "\C-c;" 'gametree-insert-score)
591(define-key gametree-mode-map "\C-c^" 'gametree-compute-and-insert-score)
592
593;;;; Goodies for mousing users
594(and (fboundp 'track-mouse)
595     (defun gametree-mouse-break-line-here (event)
596       (interactive "e")
597       (mouse-set-point event)
598       (gametree-break-line-here))
599     (defun gametree-mouse-show-children-and-entry (event)
600       (interactive "e")
601       (mouse-set-point event)
602       (gametree-show-children-and-entry))
603     (defun gametree-mouse-show-subtree (event)
604       (interactive "e")
605       (mouse-set-point event)
606       (show-subtree))
607     (defun gametree-mouse-hide-subtree (event)
608       (interactive "e")
609       (mouse-set-point event)
610       (hide-subtree))
611     (define-key gametree-mode-map [M-down-mouse-2 M-mouse-2]
612       'gametree-mouse-break-line-here)
613     (define-key gametree-mode-map [S-down-mouse-1 S-mouse-1]
614       'gametree-mouse-show-children-and-entry)
615     (define-key gametree-mode-map [S-down-mouse-2 S-mouse-2]
616       'gametree-mouse-show-subtree)
617     (define-key gametree-mode-map [S-down-mouse-3 S-mouse-3]
618       'gametree-mouse-hide-subtree))
619
620(provide 'gametree)
621
622;;; arch-tag: aaa30943-9ae4-4cc1-813d-a46f96b7e4f1
623;;; gametree.el ends here
624