lisp/tutorial.el

   1 ;;; tutorial.el --- tutorial for Emacs
   2
   3 ;; Copyright (C) 2006-2011 Free Software Foundation, Inc.
   4
   5 ;; Maintainer: FSF
   6 ;; Keywords: help, internal
   7 ;; Package: emacs
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;; Code for running the Emacs tutorial.
  27
  28 ;;; History:
  29
  30 ;; File was created 2006-09.
  31
  32 ;;; Code:
  33
  34 (require 'help-mode) ;; for function help-buffer
  35
  36 (defface tutorial-warning-face
  37   '((t :inherit font-lock-warning-face))
  38   "Face used to highlight warnings in the tutorial."
  39   :group 'help)
  40
  41 (defvar tutorial--point-before-chkeys 0
  42   "Point before display of key changes.")
  43 (make-variable-buffer-local 'tutorial--point-before-chkeys)
  44
  45 (defvar tutorial--point-after-chkeys 0
  46   "Point after display of key changes.")
  47 (make-variable-buffer-local 'tutorial--point-after-chkeys)
  48
  49 (defvar tutorial--lang nil
  50   "Tutorial language.")
  51 (make-variable-buffer-local 'tutorial--lang)
  52
  53 (defun tutorial--describe-nonstandard-key (value)
  54   "Give more information about a changed key binding.
  55 This is used in `help-with-tutorial'.  The information includes
  56 the key sequence that no longer has a default binding, the
  57 default binding and the current binding.  It also tells in what
  58 keymap the new binding has been done and how to access the
  59 function in the default binding from the keyboard.
  60
  61 For `cua-mode' key bindings that try to combine CUA key bindings
  62 with default Emacs bindings information about this is shown.
  63
  64 VALUE should have either of these formats:
  65
  66   \(cua-mode)
  67   \(current-binding KEY-FUN DEF-FUN KEY WHERE)
  68
  69 Where
  70   KEY         is a key sequence whose standard binding has been changed
  71   KEY-FUN     is the actual binding for KEY
  72   DEF-FUN     is the standard binding of KEY
  73   WHERE       is a text describing the key sequences to which DEF-FUN is
  74               bound now (or, if it is remapped, a key sequence
  75               for the function it is remapped to)"
  76   (with-output-to-temp-buffer (help-buffer)
  77     (help-setup-xref (list #'tutorial--describe-nonstandard-key value)
  78                      (called-interactively-p 'interactive))
  79     (with-current-buffer (help-buffer)
  80       (insert
  81        "Your Emacs customizations override the default binding for this key:"
  82        "\n\n")
  83       (let ((inhibit-read-only t))
  84         (cond
  85          ((eq (car value) 'cua-mode)
  86           (insert
  87            "CUA mode is enabled.
  88
  89 When CUA mode is enabled, you can use C-z, C-x, C-c, and C-v to
  90 undo, cut, copy, and paste in addition to the normal Emacs
  91 bindings.  The C-x and C-c keys only do cut and copy when the
  92 region is active, so in most cases, they do not conflict with the
  93 normal function of these prefix keys.
  94
  95 If you really need to perform a command which starts with one of
  96 the prefix keys even when the region is active, you have three
  97 options:
  98 - press the prefix key twice very quickly (within 0.2 seconds),
  99 - press the prefix key and the following key within 0.2 seconds, or
 100 - use the SHIFT key with the prefix key, i.e. C-S-x or C-S-c."))
 101          ((eq (car value) 'current-binding)
 102           (let ((cb    (nth 1 value))
 103                 (db    (nth 2 value))
 104                 (key   (nth 3 value))
 105                 (where (nth 4 value))
 106                 map
 107                 (maps (current-active-maps))
 108                 mapsym)
 109             ;; Look at the currently active keymaps and try to find
 110             ;; first the keymap where the current binding occurs:
 111             (while maps
 112               (let* ((m (car maps))
 113                      (mb (lookup-key m key t)))
 114                 (setq maps (cdr maps))
 115                 (when (eq mb cb)
 116                   (setq map m)
 117                   (setq maps nil))))
 118             ;; Now, if a keymap was found we must found the symbol
 119             ;; name for it to display to the user.  This can not
 120             ;; always be found since all keymaps does not have a
 121             ;; symbol pointing to them, but here they should have
 122             ;; that:
 123             (when map
 124               (mapatoms (lambda (s)
 125                           (and
 126                            ;; If not already found
 127                            (not mapsym)
 128                            ;; and if s is a keymap
 129                            (and (boundp s)
 130                                 (keymapp (symbol-value s)))
 131                            ;; and not the local symbol map
 132                            (not (eq s 'map))
 133                            ;; and the value of s is map
 134                            (eq map (symbol-value s))
 135                            ;; then save this value in mapsym
 136                            (setq mapsym s)))))
 137             (insert "The default Emacs binding for the key "
 138                     (key-description key)
 139                     " is the command `")
 140             (insert (format "%s" db))
 141             (insert "'.  "
 142                     "However, your customizations have "
 143                     (if cb
 144                         (format "rebound it to the command `%s'" cb)
 145                       "unbound it"))
 146             (insert ".")
 147             (when mapsym
 148               (insert "  (For the more advanced user:"
 149                       " This binding is in the keymap `"
 150                       (format "%s" mapsym)
 151                       "'.)"))
 152             (if (string= where "")
 153                 (unless (keymapp db)
 154                   (insert "\n\nYou can use M-x "
 155                           (format "%s" db)
 156                           " RET instead."))
 157               (insert "\n\nWith your current key bindings"
 158                       " you can use "
 159                       (if (string-match "^the .*menus?$" where)
 160                           ""
 161                         "the key")
 162                       where
 163                       " to get the function `"
 164                       (format "%s" db)
 165                       "'.")))
 166           (fill-region (point-min) (point)))))
 167       (help-print-return-message))))
 168
 169 (defun tutorial--sort-keys (left right)
 170   "Sort predicate for use with `tutorial--default-keys'.
 171 This is a predicate function to `sort'.
 172
 173 The sorting is for presentation purpose only and is done on the
 174 key sequence.
 175
 176 LEFT and RIGHT are the elements to compare."
 177   (let ((x (append (cadr left)  nil))
 178         (y (append (cadr right) nil)))
 179     ;; Skip the front part of the key sequences if they are equal:
 180     (while (and x y
 181                 (listp x) (listp y)
 182                 (equal (car x) (car y)))
 183       (setq x (cdr x))
 184       (setq y (cdr y)))
 185     ;; Try to make a comparision that is useful for presentation (this
 186     ;; could be made nicer perhaps):
 187     (let ((cx (car x))
 188           (cy (car y)))
 189       ;;(message "x=%s, y=%s;;;; cx=%s, cy=%s" x y cx cy)
 190       (cond
 191        ;; Lists? Then call this again
 192        ((and cx cy
 193              (listp cx)
 194              (listp cy))
 195         (tutorial--sort-keys cx cy))
 196        ;; Are both numbers? Then just compare them
 197        ((and (wholenump cx)
 198              (wholenump cy))
 199         (> cx cy))
 200        ;; Is one of them a number? Let that be bigger then.
 201        ((wholenump cx)
 202         t)
 203        ((wholenump cy)
 204         nil)
 205        ;; Are both symbols? Compare the names then.
 206        ((and (symbolp cx)
 207              (symbolp cy))
 208         (string< (symbol-name cy)
 209                  (symbol-name cx)))))))
 210
 211 (defconst tutorial--default-keys
 212   ;; On window system, `suspend-emacs' is replaced in the default
 213   ;; keymap
 214   (let* ((suspend-emacs 'suspend-frame)
 215          (default-keys
 216            `((ESC-prefix [27])
 217              (Control-X-prefix [?\C-x])
 218              (mode-specific-command-prefix [?\C-c])
 219              (save-buffers-kill-terminal [?\C-x ?\C-c])
 220
 221              ;; * SUMMARY
 222              (scroll-up-command [?\C-v])
 223              (scroll-down-command [?\M-v])
 224              (recenter-top-bottom [?\C-l])
 225
 226              ;; * BASIC CURSOR CONTROL
 227              (forward-char [?\C-f])
 228              (backward-char [?\C-b])
 229              (forward-word [?\M-f])
 230              (backward-word [?\M-b])
 231              (next-line [?\C-n])
 232              (previous-line [?\C-p])
 233              (move-beginning-of-line [?\C-a])
 234              (move-end-of-line [?\C-e])
 235              (backward-sentence [?\M-a])
 236              (forward-sentence [?\M-e])
 237              (newline "\r")
 238              (beginning-of-buffer [?\M-<])
 239              (end-of-buffer [?\M->])
 240              (universal-argument [?\C-u])
 241
 242              ;; * WHEN EMACS IS HUNG
 243              (keyboard-quit [?\C-g])
 244
 245              ;; * DISABLED COMMANDS
 246              (downcase-region [?\C-x ?\C-l])
 247
 248              ;; * WINDOWS
 249              (delete-other-windows [?\C-x ?1])
 250              ;; C-u 0 C-l
 251              ;; Type CONTROL-h k CONTROL-f.
 252
 253              ;; * INSERTING AND DELETING
 254              ;; C-u 8 * to insert ********.
 255              (delete-backward-char "\d")
 256              (delete-char [?\C-d])
 257              (backward-kill-word [?\M-\d])
 258              (kill-word [?\M-d])
 259              (kill-line [?\C-k])
 260              (kill-sentence [?\M-k])
 261              (set-mark-command [?\C-@])
 262              (set-mark-command [?\C- ])
 263              (kill-region [?\C-w])
 264              (yank [?\C-y])
 265              (yank-pop [?\M-y])
 266
 267              ;; * UNDO
 268              (undo [?\C-x ?u])
 269
 270              ;; * FILES
 271              (find-file [?\C-x ?\C-f])
 272              (save-buffer [?\C-x ?\C-s])
 273
 274              ;; * BUFFERS
 275              (list-buffers [?\C-x ?\C-b])
 276              (switch-to-buffer [?\C-x ?b])
 277              (save-some-buffers [?\C-x ?s])
 278
 279              ;; * EXTENDING THE COMMAND SET
 280              ;; C-x     Character eXtend.  Followed by one character.
 281              (execute-extended-command [?\M-x])
 282              ;; C-x C-f         Find file
 283              ;; C-x C-s         Save file
 284              ;; C-x s           Save some buffers
 285              ;; C-x C-b         List buffers
 286              ;; C-x b           Switch buffer
 287              ;; C-x C-c         Quit Emacs
 288              ;; C-x 1           Delete all but one window
 289              ;; C-x u           Undo
 290
 291              ;; * MODE LINE
 292              (describe-mode [?\C-h ?m])
 293              (set-fill-column [?\C-x ?f])
 294              (fill-paragraph [?\M-q])
 295
 296              ;; * SEARCHING
 297              (isearch-forward [?\C-s])
 298              (isearch-backward [?\C-r])
 299
 300              ;; * MULTIPLE WINDOWS
 301              (split-window-below [?\C-x ?2])
 302              (scroll-other-window [?\C-\M-v])
 303              (other-window [?\C-x ?o])
 304              (find-file-other-window [?\C-x ?4 ?\C-f])
 305
 306              ;; * RECURSIVE EDITING LEVELS
 307              (keyboard-escape-quit [27 27 27])
 308
 309              ;; * GETTING MORE HELP
 310              ;; The most basic HELP feature is C-h c
 311              (describe-key-briefly [?\C-h ?c])
 312              (describe-key [?\C-h ?k])
 313
 314              ;; * MORE FEATURES
 315              ;; F10
 316
 317              ;; * CONCLUSION
 318              ;;(iconify-or-deiconify-frame [?\C-z])
 319              (,suspend-emacs [?\C-z]))))
 320     (sort default-keys 'tutorial--sort-keys))
 321   "Default Emacs key bindings that the tutorial depends on.")
 322
 323 (defun tutorial--detailed-help (button)
 324   "Give detailed help about changed keys."
 325   (with-output-to-temp-buffer (help-buffer)
 326     (help-setup-xref (list #'tutorial--detailed-help button)
 327                      (called-interactively-p 'interactive))
 328     (with-current-buffer (help-buffer)
 329       (let* ((tutorial-buffer  (button-get button 'tutorial-buffer))
 330              (explain-key-desc (button-get button 'explain-key-desc))
 331              (changed-keys (with-current-buffer tutorial-buffer
 332                              (save-excursion
 333                                (goto-char (point-min))
 334                                (tutorial--find-changed-keys
 335                                 tutorial--default-keys)))))
 336         (when changed-keys
 337           (insert
 338            "The following key bindings used in the tutorial have been changed
 339 from the Emacs default:\n\n" )
 340           (let ((frm "   %-14s %-27s %-16s\n"))
 341             (insert (format frm
 342                             "Standard Key" "Command" "In Your Emacs")))
 343           (dolist (tk changed-keys)
 344             (let* ((def-fun     (nth 1 tk))
 345                    (key         (nth 0 tk))
 346                    (def-fun-txt (nth 2 tk))
 347                    (where       (nth 3 tk))
 348                    (remark      (nth 4 tk))
 349                    (rem-fun (command-remapping def-fun))
 350                    (key-txt (key-description key))
 351                    (key-fun (with-current-buffer tutorial-buffer (key-binding key)))
 352                    tot-len)
 353               (unless (eq def-fun key-fun)
 354                 ;; Insert key binding description:
 355                 (when (string= key-txt explain-key-desc)
 356                   (put-text-property 0 (length key-txt)
 357                                      'face 'tutorial-warning-face key-txt))
 358                 (insert "   " key-txt " ")
 359                 (indent-to 18)
 360                 ;; Insert a link describing the old binding:
 361                 (insert-button def-fun-txt
 362                                'value def-fun
 363                                'action
 364                                (lambda (button) (interactive)
 365                                  (describe-function
 366                                   (button-get button 'value)))
 367                                'follow-link t)
 368                 (indent-to 45)
 369                 (when (listp where)
 370                   (setq where "list"))
 371                 ;; Tell where the old binding is now:
 372                 (insert (format " %-16s "
 373                                 (if (string= "" where)
 374                                     (format "M-x %s" def-fun-txt)
 375                                   where)))
 376                 ;; Insert a link with more information, for example
 377                 ;; current binding and keymap or information about
 378                 ;; cua-mode replacements:
 379                 (insert-button (car remark)
 380                                'action
 381                                (lambda (b) (interactive)
 382                                  (let ((value (button-get b 'value)))
 383                                    (tutorial--describe-nonstandard-key value)))
 384                                'value (cdr remark)
 385                                'follow-link t)
 386                 (insert "\n")))))
 387
 388         (insert "
 389 It is OK to change key bindings, but changed bindings do not
 390 correspond to what the tutorial says.\n\n")
 391         (help-print-return-message)))))
 392
 393 (defun tutorial--find-changed-keys (default-keys)
 394   "Find the key bindings used in the tutorial that have changed.
 395 Return a list with elements of the form
 396
 397   '(KEY DEF-FUN DEF-FUN-TXT WHERE REMARK QUIET)
 398
 399 where
 400
 401   KEY         is a key sequence whose standard binding has been changed
 402   DEF-FUN     is the standard binding of KEY
 403   DEF-FUN-TXT is a short descriptive text for DEF-FUN
 404   WHERE       is a text describing the key sequences to which DEF-FUN is
 405               bound now (or, if it is remapped, a key sequence
 406               for the function it is remapped to)
 407   REMARK      is a list with info about rebinding. It has either of
 408               these formats:
 409
 410                 \(TEXT cua-mode)
 411                 \(TEXT current-binding KEY-FUN DEF-FUN KEY WHERE)
 412
 413               Here TEXT is a link text to show to the user.  The
 414               rest of the list is used to show information when
 415               the user clicks the link.
 416
 417               KEY-FUN is the actual binding for KEY.
 418   QUIET       is t if this changed keybinding should be handled quietly.
 419               This is used by `tutorial--display-changes'."
 420   (let (changed-keys remark)
 421     ;; Look up the bindings in a Fundamental mode buffer
 422     ;; so we do not get fooled by some other major mode.
 423     (with-temp-buffer
 424       (fundamental-mode)
 425       (dolist (kdf default-keys)
 426         ;; The variables below corresponds to those with the same names
 427         ;; described in the doc string.
 428         (let* ((key     (nth 1 kdf))
 429                (def-fun (nth 0 kdf))
 430                (def-fun-txt (format "%s" def-fun))
 431                (rem-fun (command-remapping def-fun))
 432                ;; Handle prefix definitions specially
 433                ;; so that a mode that rebinds some subcommands
 434                ;; won't make it appear that the whole prefix is gone.
 435                (key-fun (if (eq def-fun 'ESC-prefix)
 436                             (lookup-key global-map [27])
 437                           (if (eq def-fun 'Control-X-prefix)
 438                               (lookup-key global-map [24])
 439                             (key-binding key))))
 440                (where (where-is-internal (if rem-fun rem-fun def-fun)))
 441                cwhere)
 442
 443           (if where
 444               (progn
 445                 (setq cwhere (car where)
 446                       where (key-description cwhere))
 447                 (when (and (< 10 (length where))
 448                            (string= (substring where 0 (length "<menu-bar>"))
 449                                     "<menu-bar>"))
 450                   (setq where
 451                         (if (and (vectorp cwhere)
 452                                  (setq cwhere (elt cwhere 1))
 453                                  (setq cwhere
 454                                        (cadr
 455                                         (assoc cwhere
 456                                                (lookup-key global-map
 457                                                            [menu-bar]))))
 458                                  (stringp cwhere))
 459                             (format "the `%s' menu" cwhere)
 460                           "the menus"))))
 461             (setq where ""))
 462           (setq remark nil)
 463           (unless
 464               (cond ((eq key-fun def-fun)
 465                      ;; No rebinding, return t
 466                      t)
 467                     ((and key-fun
 468                           (eq key-fun (command-remapping def-fun)))
 469                      ;; Just a remapping, return t
 470                      t)
 471                     ;; cua-mode specials:
 472                     ((and cua-mode
 473                           (or (and
 474                                (equal key [?\C-v])
 475                                (eq key-fun 'cua-paste))
 476                               (and
 477                                (equal key [?\C-z])
 478                                (eq key-fun 'undo))))
 479                      (setq remark (list "cua-mode, more info" 'cua-mode))
 480                      nil)
 481                     ((and cua-mode
 482                           (or (and (eq def-fun 'ESC-prefix)
 483                                    (equal key-fun
 484                                           `(keymap
 485                                             (118 . cua-repeat-replace-region)))
 486                                    (setq def-fun-txt "\"ESC prefix\""))
 487                               (and (eq def-fun 'mode-specific-command-prefix)
 488                                    (equal key-fun
 489                                           '(keymap
 490                                             (timeout . copy-region-as-kill)))
 491                                    (setq def-fun-txt "\"C-c prefix\""))
 492                               (and (eq def-fun 'Control-X-prefix)
 493                                    (equal key-fun
 494                                           '(keymap (timeout . kill-region)))
 495                                    (setq def-fun-txt "\"C-x prefix\""))))
 496                      (setq remark (list "cua-mode replacement" 'cua-mode))
 497                      (setq where "Same key")
 498                      nil)
 499                     ;; viper-mode specials:
 500                     ((and (boundp 'viper-mode-string)
 501                           (boundp 'viper-current-state)
 502                           (eq viper-current-state 'vi-state)
 503                           (or (and (eq def-fun 'isearch-forward)
 504                                    (eq key-fun 'viper-isearch-forward))
 505                               (and (eq def-fun 'isearch-backward)
 506                                    (eq key-fun 'viper-isearch-backward))))
 507                      ;; These bindings works as the default bindings,
 508                      ;; return t
 509                      t)
 510                     ((when normal-erase-is-backspace
 511                        (or (and (equal key [C-delete])
 512                                 (equal key-fun 'kill-word))
 513                            (and (equal key [C-backspace])
 514                                 (equal key-fun 'backward-kill-word))))
 515                      ;; This is the strange handling of C-delete and
 516                      ;; C-backspace, return t
 517                      t)
 518                     (t
 519                      ;; This key has indeed been rebound. Put information
 520                      ;; in `remark' and return nil
 521                      (setq remark
 522                            (list "more info" 'current-binding
 523                                  key-fun def-fun key where))
 524                      nil))
 525             (add-to-list 'changed-keys
 526                          (list key def-fun def-fun-txt where remark nil))))))
 527     changed-keys))
 528
 529 (defun tutorial--key-description (key)
 530   (let ((desc (key-description key)))
 531     (cond ((string= "ESC" desc) "<ESC>")
 532           ((string= "RET" desc) "<Return>")
 533           ((string= "DEL" desc) "<Delback>")
 534           (t desc))))
 535
 536 (defun tutorial--display-changes ()
 537   "Display changes to some default key bindings.
 538 If some of the default key bindings that the tutorial depends on
 539 have been changed then display the changes in the tutorial buffer
 540 with some explanatory links."
 541   (let* ((changed-keys (tutorial--find-changed-keys
 542                         tutorial--default-keys))
 543          ;; Alist of element (DESC . CK) where DESC is the
 544          ;; key-description of a changed key and CK is the
 545          ;; corresponding element in `changed-keys'.
 546          (changed-keys-alist
 547           (mapcar (lambda (ck) (cons (tutorial--key-description (car ck)) ck))
 548                   changed-keys))
 549          changed-key
 550          (start (point))
 551          (case-fold-search nil)
 552          (keybindings-regexp
 553           (concat "[[:space:]]\\("
 554                   (mapconcat (lambda (kdf) (regexp-quote
 555                                             (tutorial--key-description
 556                                              (nth 1 kdf))))
 557                              tutorial--default-keys
 558                              "\\|")
 559                   "\\)[[:punct:][:space:]]")))
 560     ;; Need the custom button face for viper buttons:
 561     (if (boundp 'viper-mode-string) (require 'cus-edit))
 562
 563     (if (or changed-keys (boundp 'viper-mode-string))
 564         (let ((head  (get-lang-string tutorial--lang 'tut-chgdhead))
 565               (head2 (get-lang-string tutorial--lang 'tut-chgdhead2)))
 566           (when (and head head2)
 567             (goto-char tutorial--point-before-chkeys)
 568             (insert head " [")
 569             (insert-button head2 'tutorial-buffer (current-buffer)
 570                            'action 'tutorial--detailed-help
 571                            'follow-link t 'face 'link)
 572             (insert "]\n\n")
 573             (add-text-properties tutorial--point-before-chkeys (point)
 574                                  '(tutorial-remark remark
 575                                    face tutorial-warning-face
 576                                    read-only t)))))
 577
 578     ;; Scan the tutorial for all key sequences.
 579     (goto-char (point-min))
 580     (while (re-search-forward keybindings-regexp (point-max) t)
 581       ;; Then highlight each rebound key sequence.
 582       ;; This avoids issuing a warning for, e.g., C-x C-b if C-b is rebound.
 583       (setq changed-key (assoc (match-string 1) changed-keys-alist))
 584       (and changed-key
 585            (not (get-text-property (match-beginning 1) 'tutorial-remark))
 586            (let* ((desc    (car changed-key))
 587                   (ck      (cdr changed-key))
 588                   (key     (nth 0 ck))
 589                   (def-fun (nth 1 ck))
 590                   (where   (nth 3 ck))
 591                   s1 s2 help-string)
 592              (unless (string= where "Same key")
 593                (when (string= where "")
 594                  (setq where (format "M-x %s" def-fun)))
 595                (setq tutorial--point-after-chkeys (point-marker)
 596                      s1 (get-lang-string tutorial--lang 'tut-chgdkey)
 597                      s2 (get-lang-string tutorial--lang 'tut-chgdkey2)
 598                      help-string (and s1 s2 (format s1 desc where)))
 599                (add-text-properties (match-beginning 1) (match-end 1)
 600                                     '(face tutorial-warning-face
 601                                       tutorial-remark key-sequence))
 602                (if help-string
 603                    (if (nth 5 ck)
 604                        ;; Put help string in the tooltip.
 605                        (put-text-property (match-beginning 1) (match-end 1)
 606                                           'help-echo help-string)
 607                      ;; Put help string in the buffer.
 608                      (save-excursion
 609                        (setcar (nthcdr 5 ck) t)
 610                        (forward-line)
 611                        ;; Two or more changed keys were on the same line.
 612                        (while (eq (get-text-property (point) 'tutorial-remark)
 613                                   'remark)
 614                          (forward-line))
 615                        (setq start (point))
 616                        (insert "** " help-string " [")
 617                        (insert-button s2 'tutorial-buffer (current-buffer)
 618                                       'action 'tutorial--detailed-help
 619                                       'explain-key-desc desc 'follow-link t
 620                                       'face 'link)
 621                        (insert "] **\n")
 622                        (add-text-properties start (point)
 623                                             '(tutorial-remark remark
 624                                               rear-nonsticky t
 625                                               face tutorial-warning-face
 626                                               read-only t)))))))))))
 627
 628 (defun tutorial--saved-dir ()
 629   "Directory to which tutorials are saved."
 630   (locate-user-emacs-file "tutorial/"))
 631
 632 (defun tutorial--saved-file ()
 633   "File name in which to save tutorials."
 634   (let ((file-name tutorial--lang)
 635         (ext (file-name-extension tutorial--lang)))
 636     (when (or (not ext)
 637               (string= ext ""))
 638       (setq file-name (concat file-name ".tut")))
 639     (expand-file-name file-name (tutorial--saved-dir))))
 640
 641 (defun tutorial--remove-remarks ()
 642   "Remove the remark lines that was added to the tutorial buffer."
 643   (save-excursion
 644     (goto-char (point-min))
 645     (let (prop-start
 646           prop-end
 647           prop-val)
 648       ;; Catch the case when we already are on a remark line
 649       (while (if (get-text-property (point) 'tutorial-remark)
 650                  (setq prop-start (point))
 651                (setq prop-start (next-single-property-change (point) 'tutorial-remark)))
 652         (setq prop-end (next-single-property-change prop-start 'tutorial-remark))
 653         (setq prop-val (get-text-property prop-start 'tutorial-remark))
 654         (unless prop-end
 655           (setq prop-end (point-max)))
 656         (goto-char prop-end)
 657         (unless (eq prop-val 'key-sequence)
 658           (delete-region prop-start prop-end))))))
 659
 660 (defun tutorial--save-tutorial ()
 661   "Save the tutorial buffer.
 662 This saves the part of the tutorial before and after the area
 663 showing changed keys.  It also saves the point position and the
 664 position where the display of changed bindings was inserted."
 665   ;; This runs in a hook so protect it:
 666   (condition-case err
 667       (if (y-or-n-p "Save your position in the tutorial? ")
 668           (tutorial--save-tutorial-to (tutorial--saved-file))
 669         (message "Tutorial position not saved"))
 670     (error (message "Error saving tutorial state: %s"
 671                     (error-message-string err)))))
 672
 673 (defun tutorial--save-tutorial-to (saved-file)
 674   "Save the tutorial buffer to SAVED-FILE.
 675 See `tutorial--save-tutorial' for more information."
 676   ;; Anything to save?
 677   (when (or (buffer-modified-p)
 678             (< 1 (point)))
 679     (let ((tutorial-dir (tutorial--saved-dir))
 680           save-err)
 681       ;; The tutorial is saved in a subdirectory in the user home
 682       ;; directory. Create this subdirectory first.
 683       (unless (file-directory-p tutorial-dir)
 684         (condition-case err
 685             (make-directory tutorial-dir nil)
 686           (error (setq save-err t)
 687                  (warn "Could not create directory %s: %s" tutorial-dir
 688                        (error-message-string err)))))
 689       ;; Make sure we have that directory.
 690       (if (file-directory-p tutorial-dir)
 691           (let ((tut-point (if (= 0 tutorial--point-after-chkeys)
 692                                ;; No info about changed keys is
 693                                ;; displayed.
 694                                (point)
 695                              (if (< (point) tutorial--point-after-chkeys)
 696                                  (- (point))
 697                                (- (point) tutorial--point-after-chkeys))))
 698                 (old-point (point))
 699                 ;; Use a special undo list so that we easily can undo
 700                 ;; the changes we make to the tutorial buffer.  This is
 701                 ;; currently not needed since we now delete the buffer
 702                 ;; after saving, but kept for possible future use of
 703                 ;; this function.
 704                 buffer-undo-list
 705                 (inhibit-read-only t))
 706             ;; Delete the area displaying info about changed keys.
 707             ;;             (when (< 0 tutorial--point-after-chkeys)
 708             ;;               (delete-region tutorial--point-before-chkeys
 709             ;;                              tutorial--point-after-chkeys))
 710             ;; Delete the remarks:
 711             (tutorial--remove-remarks)
 712             ;; Put the value of point first in the buffer so it will
 713             ;; be saved with the tutorial.
 714             (goto-char (point-min))
 715             (insert (number-to-string tut-point)
 716                     "\n"
 717                     (number-to-string (marker-position
 718                                        tutorial--point-before-chkeys))
 719                     "\n")
 720             (condition-case err
 721                 (write-region nil nil saved-file)
 722               (error (setq save-err t)
 723                      (warn "Could not save tutorial to %s: %s"
 724                            saved-file
 725                            (error-message-string err))))
 726             ;; An error is raised here?? Is this a bug?
 727             (condition-case err
 728                 (undo-only)
 729               (error nil))
 730             ;; Restore point
 731             (goto-char old-point)
 732             (if save-err
 733                 (message "Could not save tutorial state.")
 734               (message "Saved tutorial state.")))
 735         (message "Can't save tutorial: %s is not a directory"
 736                  tutorial-dir)))))
 737
 738
 739 ;;;###autoload
 740 (defun help-with-tutorial (&optional arg dont-ask-for-revert)
 741   "Select the Emacs learn-by-doing tutorial.
 742 If there is a tutorial version written in the language
 743 of the selected language environment, that version is used.
 744 If there's no tutorial in that language, `TUTORIAL' is selected.
 745 With ARG, you are asked to choose which language.
 746 If DONT-ASK-FOR-REVERT is non-nil the buffer is reverted without
 747 any question when restarting the tutorial.
 748
 749 If any of the standard Emacs key bindings that are used in the
 750 tutorial have been changed then an explanatory note about this is
 751 shown in the beginning of the tutorial buffer.
 752
 753 When the tutorial buffer is killed the content and the point
 754 position in the buffer is saved so that the tutorial may be
 755 resumed later."
 756   (interactive "P")
 757   (if (boundp 'viper-current-state)
 758       (let ((prompt1
 759              "You can not run the Emacs tutorial directly because you have \
 760 enabled Viper.")
 761             (prompt2 "\nThere is however a Viper tutorial you can run instead.
 762 Run the Viper tutorial? "))
 763         (if (fboundp 'viper-tutorial)
 764             (if (y-or-n-p (concat prompt1 prompt2))
 765                 (progn (message "")
 766                        (funcall 'viper-tutorial 0))
 767               (message "Tutorial aborted by user"))
 768           (message prompt1)))
 769     (let* ((lang (if arg
 770                      (let ((minibuffer-setup-hook minibuffer-setup-hook))
 771                        (add-hook 'minibuffer-setup-hook
 772                                  'minibuffer-completion-help)
 773                        (read-language-name 'tutorial "Language: " "English"))
 774                    (if (get-language-info current-language-environment 'tutorial)
 775                        current-language-environment
 776                      "English")))
 777            (filename (get-language-info lang 'tutorial))
 778            (tut-buf-name filename)
 779            (old-tut-buf (get-buffer tut-buf-name))
 780            (old-tut-win (when old-tut-buf (get-buffer-window old-tut-buf t)))
 781            (old-tut-is-ok (when old-tut-buf
 782                             (not (buffer-modified-p old-tut-buf))))
 783            old-tut-file
 784            (old-tut-point 1))
 785       (setq tutorial--point-after-chkeys (point-min))
 786       ;; Try to display the tutorial buffer before asking to revert it.
 787       ;; If the tutorial buffer is shown in some window make sure it is
 788       ;; selected and displayed:
 789       (if old-tut-win
 790           (raise-frame
 791            (window-frame
 792             (select-window (get-buffer-window old-tut-buf t))))
 793         ;; Else, is there an old tutorial buffer? Then display it:
 794         (when old-tut-buf
 795           (switch-to-buffer old-tut-buf)))
 796       ;; Use whole frame for tutorial
 797       (delete-other-windows)
 798       ;; If the tutorial buffer has been changed then ask if it should
 799       ;; be reverted:
 800       (when (and old-tut-buf
 801                  (not old-tut-is-ok))
 802         (setq old-tut-is-ok
 803               (if dont-ask-for-revert
 804                   nil
 805                 (not (y-or-n-p
 806                       "You have changed the Tutorial buffer.  Revert it? ")))))
 807       ;; (Re)build the tutorial buffer if it is not ok
 808       (unless old-tut-is-ok
 809         (switch-to-buffer (get-buffer-create tut-buf-name))
 810         ;; (unless old-tut-buf (text-mode))
 811         (unless lang (error "Variable lang is nil"))
 812         (setq tutorial--lang lang)
 813         (setq old-tut-file (file-exists-p (tutorial--saved-file)))
 814         (let ((inhibit-read-only t))
 815           (erase-buffer))
 816         (message "Preparing tutorial ...") (sit-for 0)
 817
 818         ;; Do not associate the tutorial buffer with a file. Instead use
 819         ;; a hook to save it when the buffer is killed.
 820         (setq buffer-auto-save-file-name nil)
 821         (add-hook 'kill-buffer-hook 'tutorial--save-tutorial nil t)
 822
 823         ;; Insert the tutorial. First offer to resume last tutorial
 824         ;; editing session.
 825         (when dont-ask-for-revert
 826           (setq old-tut-file nil))
 827         (when old-tut-file
 828           (setq old-tut-file
 829                 (y-or-n-p "Resume your last saved tutorial? ")))
 830         (if old-tut-file
 831             (progn
 832               (insert-file-contents (tutorial--saved-file))
 833               (let ((enable-local-variables :safe))
 834                 (hack-local-variables))
 835               (goto-char (point-min))
 836               (setq old-tut-point
 837                     (string-to-number
 838                      (buffer-substring-no-properties
 839                       (line-beginning-position) (line-end-position))))
 840               (forward-line)
 841               (setq tutorial--point-before-chkeys
 842                     (string-to-number
 843                      (buffer-substring-no-properties
 844                       (line-beginning-position) (line-end-position))))
 845               (forward-line)
 846               (delete-region (point-min) (point))
 847               (goto-char tutorial--point-before-chkeys)
 848               (setq tutorial--point-before-chkeys (point-marker)))
 849           (insert-file-contents (expand-file-name filename tutorial-directory))
 850           (let ((enable-local-variables :safe))
 851             (hack-local-variables))
 852           (forward-line)
 853           (setq tutorial--point-before-chkeys (point-marker)))
 854
 855         (tutorial--display-changes)
 856
 857         ;; Clear message:
 858         (unless dont-ask-for-revert
 859           (message "") (sit-for 0))
 860
 861
 862         (if old-tut-file
 863             ;; Just move to old point in saved tutorial.
 864             (let ((old-point
 865                    (if (> 0 old-tut-point)
 866                        (- old-tut-point)
 867                      (+ old-tut-point tutorial--point-after-chkeys))))
 868               (when (< old-point 1)
 869                 (setq old-point 1))
 870               (goto-char old-point))
 871           ;; Delete the arch-tag line, so as not to confuse readers.
 872           (goto-char (point-max))
 873           (if (search-backward ";;; arch-tag: " nil t)
 874               (delete-region (point) (point-max)))
 875           (goto-char (point-min))
 876           (search-forward "\n<<")
 877           (beginning-of-line)
 878           ;; Convert the <<...>> line to the proper [...] line,
 879           ;; or just delete the <<...>> line if a [...] line follows.
 880           (cond ((save-excursion
 881                    (forward-line 1)
 882                    (looking-at "\\["))
 883                  (delete-region (point) (progn (forward-line 1) (point))))
 884                 ((looking-at "<<Blank lines inserted.*>>")
 885                  (replace-match "[Middle of page left blank for didactic purposes.   Text continues below]"))
 886                 (t
 887                  (looking-at "<<")
 888                  (replace-match "[")
 889                  (search-forward ">>")
 890                  (replace-match "]")))
 891           (beginning-of-line)
 892           ;; FIXME: if the window is not tall, and especially if the
 893           ;; big red "NOTICE: The main purpose..." text has been
 894           ;; inserted at the start of the buffer, the "type C-v to
 895           ;; move to the next screen" might not be visible on the
 896           ;; first screen (n < 0).  How will the novice know what to do?
 897           (let ((n (- (window-height (selected-window))
 898                       (count-lines (point-min) (point))
 899                       6)))
 900             (if (< n 8)
 901                 (progn
 902                   ;; For a short gap, we don't need the [...] line,
 903                   ;; so delete it.
 904                   (delete-region (point) (progn (end-of-line) (point)))
 905                   (if (> n 0) (newline n)))
 906               ;; Some people get confused by the large gap.
 907               (newline (/ n 2))
 908
 909               ;; Skip the [...] line (don't delete it).
 910               (forward-line 1)
 911               (newline (- n (/ n 2)))))
 912           (goto-char (point-min)))
 913         (setq buffer-undo-list nil)
 914         (set-buffer-modified-p nil)))))
 915
 916
 917 ;; Below is some attempt to handle language specific strings. These
 918 ;; are currently only used in the tutorial.
 919
 920 (defconst lang-strings
 921   '(("English" .
 922      ((tut-chgdkey . "%s has been rebound, but you can use %s instead")
 923       (tut-chgdkey2 . "More")
 924       (tut-chgdhead . "
 925  NOTICE: The main purpose of the Emacs tutorial is to teach you
 926  the most important standard Emacs commands (key bindings).
 927  However, your Emacs has been customized by changing some of
 928  these basic editing commands, so it doesn't correspond to the
 929  tutorial.  We have inserted colored notices where the altered
 930  commands have been introduced.")
 931       (tut-chgdhead2 . "More"))))
 932   "Language specific strings for Emacs.
 933 This is an association list with the keys equal to the strings
 934 that can be returned by `read-language-name'.  The elements in
 935 the list are themselves association lists with keys that are
 936 string ids and values that are the language specific strings.
 937
 938 See `get-lang-string' for more information.")
 939
 940 (defun get-lang-string (lang stringid &optional no-eng-fallback)
 941   "Get a language specific string for Emacs.
 942 In certain places Emacs can replace a string shown to the user with
 943 a language specific string.  This function retrieves such strings.
 944
 945 LANG is the language specification.  It should be one of those
 946 strings that can be returned by `read-language-name'.  STRINGID
 947 is a symbol that specifies the string to retrieve.
 948
 949 If no string is found for STRINGID in the chosen language then
 950 the English string is returned unless NO-ENG-FALLBACK is non-nil.
 951
 952 See `lang-strings' for more information.
 953
 954 Currently this feature is only used in `help-with-tutorial'."
 955   (let ((my-lang-strings (assoc lang lang-strings))
 956         (found-string))
 957     (when my-lang-strings
 958       (let ((entry (assoc stringid (cdr my-lang-strings))))
 959         (when entry
 960           (setq found-string (cdr entry)))))
 961     ;; Fallback to English strings
 962     (unless (or found-string
 963                 no-eng-fallback)
 964       (setq found-string (get-lang-string "English" stringid t)))
 965     found-string))
 966
 967 ;;(get-lang-string "English" 'tut-chgdkey)
 968
 969 (provide 'tutorial)
 970
 971 ;;; tutorial.el ends here