Re: cua-mode and the tutorial

[Kim F. Storm]

Lennart Borgman <address@hidden> writes:

> Hi Kim,
>
> I am trying to merge info about cua-mode and viper-mode into the
> tutorial. Can you please look at the attached file and give some
> comments? 

I don't see any problem with the things you have written about
cua-mode as such.

However, the statement "you have enabled cua-mode" may very
well be false  (if someone is able to enable cua-mode, they
are likely to be past tutorial state).  So maybe the text
should be "cua-mode is enabled".



>           Especially what should be said about the ESC key.

I don't use viper, so I prefer not to answer that question!

I tried to enter the tutorial after enabling viper-mode,
but I didn't see any information about VIPER in the help
buffer...  so I don't know how to activate the stuff about
vi in your patch...


In any case, I think that emacs should simply reject to run the
tutorial if VIPER is enabled (or turn it off in the tutorial and NOT
give the option to enable it in the tutorial).
  
The current code to deal with this is overly complex -- and
the tutorial is about learning to use basic Emacs bindings.

Does the tutorial make sense at all in viper mode???


BTW, the patch mixes two sets of changes ... for the key binding
stuff and for running multiple tutorials at the same time.

The latter part should IMO, never be installed -- it is just
too obscure for normal users!


>
> Best wishes,
> L
> (defun help--describe-nonstandard-key(value)
>   (let ((maps (current-active-maps t)))
>     (with-output-to-temp-buffer (help-buffer)
>       (help-setup-xref (list #'help-describe-nonstandard-key value)
>                        (interactive-p))
>       (with-current-buffer (help-buffer)
>         (insert "Emacs default key binding has been changed in your 
> setup:\n\n")
>         (let ((inhibit-read-only t))
>           (cond
>            ((eq (car value) 'cua-mode)
>             (insert
>              "You have enabled `cua-mode'.
>
> When `cua-mode' is enabled, you can use C-z, C-x, C-c, and C-v to
> undo, cut, copy, and paste in addition to the normal Emacs
> bindings.  The C-x and C-c keys only do cut and copy when the
> region is active, so in most cases, they do not conflict with the
> normal function of these prefix keys.
>
> If you really need to perform a command which starts with one of
> the prefix keys even when the region is active, you have three
> options:
> - press the prefix key twice very quickly (within 0.2 seconds),
> - press the prefix key and the following key within 0.2 seconds, or
> - use the SHIFT key with the prefix key, i.e. C-S-x or C-S-c."))
>            ((eq (car value) 'current-binding)
>             (let ((cb    (nth 1 value))
>                   (db    (nth 2 value))
>                   (key   (nth 3 value))
>                   (where (nth 4 value))
>                   map
>                   mapsym)
>               ;; Try to find the map where the binding occurs
>               (while maps
>                 (let* ((m (car maps))
>                        (mb (lookup-key m key t)))
>                   (setq maps (cdr maps))
>                   (when (eq mb cb)
>                     (setq map m)
>                     (setq maps nil))))
>               (when map
>                 (if (eq map global-map)
>                     (setq mapsym 'global-map)
>                   (mapatoms (lambda (s)
>                               (when (and (boundp s)
>                                          (keymapp (symbol-value s)))
>                                 (unless (eq s 'map)
>                                   (when (equal map (symbol-value s))
>                                     (when (member map (current-active-maps))
>                                       (setq mapsym s)))))))))
>               (insert "Emacs default binding for the key "
>                       (key-description key)
>                       " is the function `")
>               (insert (format "%s" db))
>               (insert "'.  "
>                       "This key has however been rebound to the function `")
>               (insert (format "%s" cb))
>               (insert "'.")
>               (when mapsym
>                 (insert "  This binding is in the keymap variable `")
>                 (insert (format "%s" mapsym))
>                 (insert "'."))
>               (if (string= where "")
>                   (unless (keymapp db)
>                     (insert "\n\nYou can use M-x "
>                             (format "%s" db)
>                             " RET instead."))
>                 (insert "\n\nWith you current key bindings"
>                         " you can use the key "
>                         where
>                         " to get the function `"
>                         (format "%s" db)
>                         "'."))
>               ))))
>         (fill-region (point-min)(point))
>         (print-help-return-message)))))
>
> (defvar help-tutorial-default-keys
>   '(
>     ;; These are not mentioned but are basic:
>     (ESC-prefix [27])
>     (Control-X-prefix [?\C-x])
>     (mode-specific-command-prefix [?\C-c])
>
>     (save-buffers-kill-emacs [?\C-x ?\C-c])
>
>
>     ;; * SUMMARY
>     (scroll-up [?\C-v])
>     (scroll-down [?\M-v])
>     (recenter [?\C-l])
>
>
>     ;; * BASIC CURSOR CONTROL
>     (forward-char [?\C-f])
>     (backward-char [?\C-b])
>
>     (forward-word [?\M-f])
>     (backward-word [?\M-b])
>
>     (next-line [?\C-n])
>     (previous-line [?\C-p])
>
>     (move-beginning-of-line [?\C-a])
>     (move-end-of-line [?\C-e])
>
>     (backward-sentence [?\M-a])
>     (forward-sentence [?\M-e])
>
>
>     (beginning-of-buffer [?\M-<])
>     (end-of-buffer [?\M->])
>
>     (universal-argument [?\C-u])
>
>
>     ;; * WHEN EMACS IS HUNG
>     (keyboard-quit [?\C-g])
>
>
>     ;; * DISABLED COMMANDS
>     (downcase-region [?\C-x ?\C-l])
>
>
>     ;; * WINDOWS
>     (delete-other-windows [?\C-x ?1])
>     ;; C-u 0 C-l
>     ;; Type CONTROL-h k CONTROL-f.
>
>
>     ;; * INSERTING AND DELETING
>     ;; C-u 8 * to insert ********.
>
>     (delete-backward-char [backspace])
>     (delete-char [?\C-d])
>
>     (backward-kill-word [(meta backspace)])
>     (kill-word [?\M-d])
>
>     (kill-line [?\C-k])
>     (kill-sentence [?\M-k])
>
>     (set-mark-command address@hidden)
>     (set-mark-command [?\C- ])
>     (kill-region [?\C-w])
>     (yank [?\C-y])
>     (yank-pop [?\M-y])
>
>
>     ;; * UNDO
>     (advertised-undo [?\C-x ?u])
>     (advertised-undo [?\C-x ?u])
>
>
>     ;; * FILES
>     (find-file [?\C-x ?\C-f])
>     (save-buffer [?\C-x ?\C-s])
>
>
>     ;; * BUFFERS
>     (list-buffers [?\C-x ?\C-b])
>     (switch-to-buffer [?\C-x ?b])
>     (save-some-buffers [?\C-x ?s])
>
>
>     ;; * EXTENDING THE COMMAND SET
>     ;; C-x    Character eXtend.  Followed by one character.
>     (execute-extended-command [?\M-x])
>
>     ;; C-x C-f                Find file
>     ;; C-x C-s                Save file
>     ;; C-x s          Save some buffers
>     ;; C-x C-b                List buffers
>     ;; C-x b          Switch buffer
>     ;; C-x C-c                Quit Emacs
>     ;; C-x 1          Delete all but one window
>     ;; C-x u          Undo
>
>
>     ;; * MODE LINE
>     (describe-mode [?\C-h ?m])
>
>     (set-fill-column [?\C-x ?f])
>     (fill-paragraph [?\M-q])
>
>
>     ;; * SEARCHING
>     (isearch-forward [?\C-s])
>     (isearch-backward [?\C-r])
>
>
>     ;; * MULTIPLE WINDOWS
>     (split-window-vertically [?\C-x ?2])
>     (scroll-other-window [?\C-\M-v])
>     (other-window [?\C-x ?o])
>     (find-file-other-window [?\C-x ?4 ?\C-f])
>
>
>     ;; * RECURSIVE EDITING LEVELS
>     (keyboard-escape-quit [27 27 27])
>
>
>     ;; * GETTING MORE HELP
>     ;; The most basic HELP feature is C-h c
>     (describe-key-briefly [?\C-h ?c])
>     (describe-key [?\C-h ?k])
>
>
>     ;; * MORE FEATURES
>     ;; F10
>
>
>     ;; * CONCLUSION
>     (iconify-or-deiconify-frame [?\C-z])
>     )
>   "Default Emacs key bindings that are used in the tutorial")
>
> (defun help-tutorial-sort-keys (left right)
>   "Sort predicate for use with `help-tutorial-default-keys'.
> This is a predicate function to `sort'.
>
> The sorting is for presentation purpose only and is done on the
> key sequence."
>   (let ((x (append (cadr left)  nil))
>         (y (append (cadr right) nil)))
>     ;; Skip the front part of the key sequences if they are equal:
>     (while (and x y
>                 (equal (car x) (car y)))
>       (setq x (cdr x))
>       (setq y (cdr y)))
>     ;; Try to make a comparition that is useful for presentation (this
>     ;; could be made nicer perhaps):
>     (let ((cx (car x))
>           (cy (car y)))
>       (cond ((and (listp cx)
>                   (listp cy))
>              (> (length cx)(length cy)))
>             ((listp cx)
>              nil)
>             ((listp cy)
>              t)
>             ((and (symbolp cx)
>                   (symbolp cy))
>              (string< (symbol-name cy)
>                       (symbol-name cx)))
>             ((symbolp cx)
>              nil)
>             ((symbolp cy)
>              t)
>             (t
>              (> (car x)(car y)))))))
>
> ;;;###autoload
> (defun help-with-tutorial (&optional arg dont-ask-for-revert)
>   "Select the Emacs learn-by-doing tutorial.
> If there is a tutorial version written in the language
> of the selected language environment, that version is used.
> If there's no tutorial in that language, `TUTORIAL' is selected.
> With ARG, you are asked to choose which language.
> If DONT-ASK-FOR-REVERT is non-nil the buffer is reverted without
> any question when restarting the tutorial."
>   (interactive "P")
>   (let* ((lang (if arg
>                    (let ((minibuffer-setup-hook minibuffer-setup-hook))
>                      (add-hook 'minibuffer-setup-hook
>                                'minibuffer-completion-help)
>                      (read-language-name 'tutorial "Language: " "English"))
>                  (if (get-language-info current-language-environment 
> 'tutorial)
>                      current-language-environment
>                    "English")))
>          (filename (get-language-info lang 'tutorial))
>          ;; Choose a buffer name including the language so that
>          ;; several languages can be tested simultaneously:
>          (tut-buf-name (concat "TUTORIAL (" lang ")"))
>          (old-tut-buf (get-buffer tut-buf-name))
>          (old-tut-win (when old-tut-buf (get-buffer-window old-tut-buf t)))
>          (old-tut-is-ok (when old-tut-buf
>                           (not (buffer-modified-p old-tut-buf))))
>          (point-after-message 1))
>     ;; Try to display the tutorial buffer before asking to revert it.
>     ;; If the tutorial buffer is shown in some window make sure it is
>     ;; selected and displayed:
>     (if old-tut-win
>         (raise-frame
>          (window-frame
>           (select-window (get-buffer-window old-tut-buf t))))
>       ;; Is there an old tutorial buffer? Then display it:
>       (when old-tut-buf
>         (switch-to-buffer old-tut-buf)))
>     ;; If the tutorial buffer has been changed then ask if it should
>     ;; be reverted:
>     (when (and old-tut-buf
>                (not old-tut-is-ok))
>       (setq old-tut-is-ok
>             (if dont-ask-for-revert
>                 nil
>               (not (y-or-n-p
>                     "You have changed the Tutorial buffer.  Revert it? ")))))
>     ;; Use whole frame for tutorial
>     (delete-other-windows)
>     ;; (Re)build the tutorial buffer if it is not ok
>     (unless old-tut-is-ok
>       (switch-to-buffer (get-buffer-create tut-buf-name))
>       (let ((inhibit-read-only t))
>         (erase-buffer))
>       (message "Preparing tutorial ...")(sit-for 0)
>
>       (setq default-directory (expand-file-name "~/"))
>       (setq buffer-auto-save-file-name nil)
>       (insert-file-contents (expand-file-name filename data-directory))
>       (hack-local-variables)
>
>
>       ;; Check if there are key bindings that may disturb the
>       ;; tutorial.  If so tell the user.
>       (let* (changed-keys
>              (default-keys (sort help-tutorial-default-keys
>                                  'help-tutorial-sort-keys))
>              ;; On window system suspend Emacs is replaced in the
>              ;; default keymap so honor this here. (Is this true for
>              ;; all window-system?  It is at least done in mac-win.el,
>              ;; w32-win.el and x-win.el.)
>              (suspend-emacs (if window-system
>                                 'iconify-or-deiconify-frame
>                               'suspend-emacs))
>              ;; Make key bindings for moving between link fields in
>              ;; the list of changed key bindings.
>              (tab-map (let ((map (make-sparse-keymap)))
>                         (define-key map [tab] 'forward-button)
>                         (define-key map [(shift tab)] 'backward-button)
>                         (define-key map [(meta tab)] 'backward-button)
>                         map)))
>
>         (let (expr
>               key
>               def-fun
>               def-fun-txt
>               rem-fun
>               key-fun
>               where
>               remark
>               )
>           ;; Check if the default Emacs key bindings that are used in
>           ;; the tutorial have been changed.:
>           (dolist (kdf default-keys)
>             (setq key     (nth 1 kdf))
>             (setq def-fun (nth 0 kdf))
>             (setq def-fun-txt (format "%s" def-fun))
>             (setq rem-fun (command-remapping def-fun))
>             (setq key-fun (key-binding key))
>             (setq where (where-is-internal (if rem-fun rem-fun def-fun)))
>             (if where
>                 (progn
>                   (setq where (key-description (car where)))
>                   (when (and (< 10 (length where))
>                              (string= (substring where 0 (length 
> "<menu-bar>"))
>                                       "<menu-bar>"))
>                     (setq where "The menus")))
>               (setq where ""))
>             (setq remark nil)
>             (unless
>                 (cond ( (eq key-fun def-fun)
>                         t)
>                       ( (eq key-fun (command-remapping def-fun))
>                         (setq remark (list "Remapped" nil))
>                         t)
>                       ;; cua-mode specials:
>                       ( (and cua-mode
>                              (or (and
>                                   (equal key [?\C-v])
>                                   (eq key-fun 'cua-paste))
>                                  (and
>                                   (equal key [?\C-z])
>                                   (eq key-fun 'undo))))
>                         (setq remark (list "cua-mode, more info" 'cua-mode))
>                         nil)
>                       ( (and cua-mode
>                              (or
>                               (and (eq def-fun 'ESC-prefix)
>                                    (equal key-fun
>                                           `(keymap
>                                             (118 . 
> cua-repeat-replace-region))))
>                               (and (eq def-fun 'mode-specific-command-prefix)
>                                    (equal key-fun
>                                           '(keymap
>                                             (timeout . copy-region-as-kill))))
>                               (and (eq def-fun 'Control-X-prefix)
>                                    (equal key-fun
>                                           '(keymap (timeout . 
> kill-region))))))
>                         (setq remark (list "cua-mode replacement" 'cua-mode))
>                         (cond
>                          ((eq def-fun 'mode-specific-command-prefix)
>                           (setq def-fun-txt "\"C-c prefix\""))
>                          ((eq def-fun 'Control-X-prefix)
>                           (setq def-fun-txt "\"C-x prefix\""))
>                          ((eq def-fun 'ESC-prefix)
>                           (setq def-fun-txt "\"ESC prefix\"")))
>                         (setq where "Same key")
>                         nil)
>                       ;; viper-mode specials:
>                       ( (and (boundp 'viper-mode)
>                              viper-mode
>                              (eq viper-current-state 'vi-state)
>                              (or (and (eq def-fun 'isearch-forward)
>                                       (eq key-fun 'viper-isearch-forward))
>                                  (and (eq def-fun 'isearch-backward)
>                                       (eq key-fun 'viper-isearch-backward))))
>                         t)
>                       ;; The strange handling of C-delete and
>                       ;; C-backspace:
>                       ( (when normal-erase-is-backspace
>                           (or (and (equal key [C-delete])
>                                    (equal key-fun 'kill-word))
>                               (and (equal key [C-backspace])
>                                    (equal key-fun 'backward-kill-word))))
>                         t)
>                       ( t
>                         (setq remark
>                               (list "more info" 'current-binding
>                                     key-fun def-fun key where))
>                         nil))
>               (add-to-list 'changed-keys
>                            (list key def-fun def-fun-txt where remark)))))
>
>         ;; Clear message:
>         (unless dont-ask-for-revert
>           (message "")(sit-for 0))
>
>         ;; If some Emacs default key bindings have been changed then
>         ;; display the changes in the tutorial buffer with some
>         ;; explanatory links:
>         (when (or changed-keys
>                   (and (boundp 'viper-mode)
>                        viper-mode))
>           ;; Need the custom button face for viper buttons:
>           (when (and (boundp 'viper-mode)
>                      viper-mode)
>             (require 'cus-edit))
>           (forward-line)
>           (let ((start (point))
>                 end)
>             (insert "
>  NOTICE: One of the main purposes of the tutorial is that You should
>  be able to learn some important Emacs default key bindings.  However
>  when you started the tutorial the following key bindings used in the
>  tutorial had been changed from Emacs default:\n\n" )
>             (when changed-keys
>               (let ((frm "   %-9s %-27s %-11s %s\n"))
>                 (insert (format frm "KEY" "DEFAULT BINDING" "IS NOW ON" 
> "REMARK")))
>               (dolist (tk changed-keys)
>                 (let* ((def-fun     (nth 1 tk))
>                        (key         (nth 0 tk))
>                        (def-fun-txt (nth 2 tk))
>                        (where       (nth 3 tk))
>                        (remark      (nth 4 tk))
>                        (rem-fun (command-remapping def-fun))
>                        (key-txt (key-description key))
>                        (key-fun (key-binding key))
>                        tot-len)
>                   (unless (eq def-fun key-fun)
>                     ;; Insert key binding description:
>                     (insert "   " key-txt " ")
>                     (setq tot-len (length key-txt))
>                     (when (> 9 tot-len)
>                       (insert (make-string (- 9 tot-len) ? ))
>                       (setq tot-len 9))
>                     ;; Insert a link describing the old binding:
>                     (insert-button def-fun-txt
>                                    'value def-fun
>                                    'action
>                                    (lambda(button) (interactive)
>                                      (describe-function
>                                       (button-get button 'value)))
>                                    'follow-link t
>                                    'read-only t
>                                    'face '(:inherit link
>                                                     :background "yellow"))
>                     (setq tot-len (+ tot-len (length def-fun-txt)))
>                     (when (> 36 tot-len)
>                       (insert (make-string (- 36 tot-len) ? )))
>                     (when (listp where)
>                       (setq where "list"))
>                     ;; Tell where the old binding is now:
>                     (insert (format " %-11s " where))
>                     ;; Insert a link with more information, for example
>                     ;; current binding and keymap or information about
>                     ;; cua-mode replacements:
>                     (insert-button (car remark)
>                                    'action
>                                    (lambda(b) (interactive)
>                                      (let ((value (button-get b 'value)))
>                                        (help--describe-nonstandard-key 
> value)))
>                                    'value (cdr remark)
>                                    'follow-link t
>                                    'face '(:inherit link
>                                                     :background "yellow"))
>                     (insert "\n")))))
>
>             ;; Viper turns itself off in the tutorial buffer by
>             ;; default. Explain this and add some more information
>             ;; about it:
>             (when (and (boundp 'viper-mode)
>                        viper-mode)
>               (insert "\n   INFORMATION ABOUT VIPER\n")
>               (cond
>                ((eq viper-current-state 'emacs-state)
>                 (insert "
>    You have enabled Viper mode, but in the tutorial buffer Viper
>    mode is currently turned off.  You can however turn it on if
>    you want to.  This may enable you to see what key bindings
>    that Viper conflicts with:\n     ")
>                 (insert-button " Turn on Viper here! "
>                                'action
>                                (lambda(b) (interactive)
>                                  (let ((arg (button-get b 'value)))
>                                    (viper-mode)
>                                    (set-buffer-modified-p t)
>                                    (help-with-tutorial arg t)))
>                                'value arg
>                                'follow-link t
>                                'face 'custom-button
>                                'mouse-face 'custom-button-mouse
>                                )
>                 ;;(insert ")")
>                 )
>                (t
>                 (insert "
>    You have enabled Viper mode in the tutorial buffer.  Some of
>    the changed key bindings above depends on the Viper state.
>    When you started the tutorial the Viper state was ")
>                 (cond
>                  ((eq viper-current-state 'vi-state)
>                   (insert "vi."))
>                  (t
>                   (insert "some insert state.")))
>                 (insert "\n     ")
>                 (cond
>                  ((eq viper-current-state 'vi-state)
>                   (insert-button " Restart tutorial in Viper insert state! "
>                                  'action
>                                  (lambda(b) (interactive)
>                                    (let ((arg (button-get b 'value)))
>                                      (viper-insert nil)
>                                      (set-buffer-modified-p t)
>                                      (help-with-tutorial arg t)))
>                                  'value arg
>                                  'follow-link t
>                                  'face 'custom-button
>                                  'mouse-face 'custom-button-mouse))
>                  ((not (eq viper-current-state 'vi-state))
>                   (insert-button " Restart tutorial in Viper vi state! "
>                                  'action
>                                  (lambda(b) (interactive)
>                                    (let ((arg (button-get b 'value))
>                                          (cmd
>                                           (cond ((eq viper-current-state 
> 'vi-state)
>                                                  'viper-ESC)
>                                                 ((eq viper-current-state 
> 'insert-state)
>                                                  'viper-exit-insert-state)
>                                                 ((eq viper-current-state 
> 'replace-state)
>                                                  
> 'viper-replace-state-exit-cmd)
>                                                 (t 'viper-change-state-to-vi)
>                                                 )))
>                                      (call-interactively cmd)
>                                      (set-buffer-modified-p t)
>                                      (help-with-tutorial arg t)))
>                                  'value arg
>                                  'follow-link t
>                                  'face 'custom-button
>                                  'mouse-face 'custom-button-mouse)))
>                 (insert "  ")
>                 (insert-button " Turn off Viper here! "
>                                'action
>                                (lambda(b) (interactive)
>                                  (let ((arg (button-get b 'value)))
>                                    (kill-buffer (current-buffer))
>                                    (help-with-tutorial arg t)))
>                                'value arg
>                                'follow-link t
>                                'face 'custom-button
>                                'mouse-face 'custom-button-mouse)))
>               (insert "\n   If you want to learn Viper keys please see the ")
>               (insert-button "Viper manual"
>                              'action
>                              (lambda(button) (interactive)
>                                (info-other-window "(viper)")
>                                (message "Type C-x 0 to close the new window"))
>                              'follow-link t
>                              'read-only t
>                              'face '(:inherit link
>                                               :background "yellow"))
>               (insert ".\n"))
>
>             (insert "
>  It is legitimate to change key bindings, but changed bindings do not
>  correspond to what the tutorial says.  (See also " )
>             (insert-button "Key Binding Conventions"
>                            'action
>                            (lambda(button) (interactive)
>                              (info-other-window
>                               "(elisp) Key Binding Conventions")
>                              (message "Type C-x 0 to close the new window"))
>                            'follow-link t
>                            'read-only t
>                            'face '(:inherit link
>                                             :background "yellow"))
>             (insert ".)\n\n")
>             (setq end (point))
>             (put-text-property start end
>                                'face
>                                ;; The default warning face does not
>                                ;;look good in this situation. Instead
>                                ;;try something that could be
>                                ;;recognized from warnings in normal
>                                ;;life:
>                                ;; 'font-lock-warning-face
>                                (list :background "yellow" :foreground "#c00"))
>             (put-text-property start end 'local-map tab-map)
>             (let ((inhibit-read-only t))
>               (put-text-property start end 'read-only t)))))
>
>       (setq point-after-message (point))
>
>       (goto-char (point-min))
>       (search-forward "\n<<")
>       (beginning-of-line)
>       ;; Convert the <<...>> line to the proper [...] line,
>       ;; or just delete the <<...>> line if a [...] line follows.
>       (cond ((save-excursion
>                (forward-line 1)
>                (looking-at "\\["))
>              (delete-region (point) (progn (forward-line 1) (point))))
>             ((looking-at "<<Blank lines inserted.*>>")
>              (replace-match "[Middle of page left blank for didactic 
> purposes.   Text continues below]"))
>             (t
>              (looking-at "<<")
>              (replace-match "[")
>              (search-forward ">>")
>              (replace-match "]")))
>       (beginning-of-line)
>       (let ((n (- (window-height (selected-window))
>                   (count-lines (point-min) (point))
>                   6)))
>         (if (< n 8)
>             (progn
>               ;; For a short gap, we don't need the [...] line,
>               ;; so delete it.
>               (delete-region (point) (progn (end-of-line) (point)))
>               (newline n))
>           ;; Some people get confused by the large gap.
>           (newline (/ n 2))
>
>           ;; Skip the [...] line (don't delete it).
>           (forward-line 1)
>           (newline (- n (/ n 2)))))
>       (goto-char (point-min))
>       (setq buffer-undo-list nil)
>       (set-buffer-modified-p nil))))

-- 
Kim F. Storm <address@hidden> http://www.cua.dk