X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lilypond-mode.el;h=bc10329dde7ec7043ee55bc58343248d7cc9920d;hb=01643a66775017fd07d17fccc14cb577a1403ebc;hp=3c28d17a0678ecfd887753247db1c9cf4fd3a26b;hpb=1d7c8ec4333a08c082b361a8bbe6936ff815b773;p=lilypond.git

diff --git a/lilypond-mode.el b/lilypond-mode.el
index 3c28d17a06..bc10329dde 100644
--- a/lilypond-mode.el
+++ b/lilypond-mode.el
@@ -3,30 +3,23 @@
 ;;;
 ;;; source file of the GNU LilyPond music typesetter
 ;;;  
-;;; (c) 1999--2001 Jan Nieuwenhuizen <janneke@gnu.org>
+;;; (c)  1999--2003 Jan Nieuwenhuizen <janneke@gnu.org>
 ;;; 
-;;; Changed 2001--2002 Heikki Junes <heikki.junes@hut.fi>
+;;; Changed 2001--2003 Heikki Junes <heikki.junes@hut.fi>
 ;;;    * Add PS-compilation, PS-viewing and MIDI-play (29th Aug 2001)
 ;;;    * Keyboard shortcuts (12th Sep 2001)
 ;;;    * Inserting tags, inspired on sgml-mode (11th Oct 2001)
 ;;;    * Autocompletion & Info (23rd Nov 2002)
-;;;
-;;; Changed 2002 Carlos Betancourt <carlos.betancourt@chello.be>
-;;;    * Added spanish-note-replacements
 
 ;;; Inspired on auctex
 
 ;;; Look lilypond-init.el or Documentation/topdocs/INSTALL.texi
 ;;; for installing instructions.
 
-;;; TODO:
-;;;    * XEmacs, broken ?
-;;;    * parenthesis matching
-
 (require 'easymenu)
 (require 'compile)
 
-(defconst LilyPond-version "1.7.9"
+(defconst LilyPond-version "1.8.0"
   "`LilyPond-mode' version number.")
 
 (defconst LilyPond-help-address "bug-lilypond@gnu.org"
@@ -35,6 +28,9 @@
 (defvar LilyPond-mode-hook nil
   "*Hook called by `LilyPond-mode'.")
 
+(defvar LilyPond-region-file-prefix "emacs-lily"
+  "File prefix for commands on buffer or region.")
+
 ;; FIXME: find ``\score'' in buffers / make settable?
 (defun LilyPond-master-file ()
   ;; duh
@@ -50,6 +46,10 @@
   '(("\\([a-zA-Z]?:?[^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 2))
   "Regexp used to match LilyPond errors.  See `compilation-error-regexp-alist'.")
 
+(defvar LilyPond-imenu nil
+  "A flag to tell whether LilyPond-imenu is turned on.")
+(make-variable-buffer-local 'LilyPond-imenu)
+
 (defcustom LilyPond-include-path ".:/tmp"
   "* LilyPond include path."
   :type 'string
@@ -65,17 +65,20 @@ Finds file lilypond-words from load-path."
       (setq fn (concat (car lp) "/" words-file))
       (if (not (file-readable-p fn)) 
 	  (progn (setq fn nil) (setq lp (cdr lp)))))
+    (if (not fn)
+	(progn (message "Warning: `lilypond.words' not found in `load-path'. See `lilypond-init.el'.")
+	       (sit-for 5 0)))
     fn))
 
 (defun LilyPond-add-dictionary-word (x)
-  "Contains all words: keywords, identifiers, reserved words."
+  "Contains all words: \keywords \Identifiers and ReservedWords."
   (nconc '(("" . 1)) x))
 
 ;; creates dictionary if empty
-(if (eq (length (LilyPond-add-dictionary-word ())) 1)
+(if (and (eq (length (LilyPond-add-dictionary-word ())) 1)
+	 (not (eq (LilyPond-words-filename) nil)))
     (progn
-      (setq fn (LilyPond-words-filename))
-      (setq b (find-file-noselect fn t t))
+      (setq b (find-file-noselect (LilyPond-words-filename) t t))
       (setq m (set-marker (make-marker) 1 (get-buffer b)))
       (setq i 1)
       (while (> (buffer-size b) (marker-position m))
@@ -85,41 +88,71 @@ Finds file lilypond-words from load-path."
 	(LilyPond-add-dictionary-word (list copy)))
       (kill-buffer b)))
 
-(defconst LilyPond-keywords 
-  (let ((wordlist ())
-	(co (all-completions "" (LilyPond-add-dictionary-word ()))))
+(defvar LilyPond-insert-tag-current ""
+  "The last command selected from the LilyPond-Insert -menu.")
+
+(defconst LilyPond-menu-keywords 
+  (let ((wordlist '()) ; add syntax entries to lilypond.words
+	(co (all-completions "" (LilyPond-add-dictionary-word ())))
+	(currword ""))
     (progn
       (while (> (length co) 0)
-	(if (> (length (car co)) 1)
-	    (if (and (string-equal "\\" (substring (car co) 0 1))
-		     (string-equal (downcase (car co)) (car co)))
-		(add-to-list 'wordlist (car co))))
-	(setq co (cdr co)))
+	(setq currword (car co))
+	(if (string-equal "-" (car (setq co (cdr co))))
+	    (progn
+	      (add-to-list 'wordlist currword)
+	      (while (and (> (length co) 0)
+			  (not (string-equal "-" (car (setq co (cdr co))))))))))
+      (reverse wordlist)))
+  "Keywords inserted from LilyPond-Insert-menu.")
+
+(defconst LilyPond-keywords
+  (let ((wordlist '("\\score")) ; add \keywords to lilypond.words
+	(co (all-completions "" (LilyPond-add-dictionary-word ())))
+	(currword ""))
+    (progn
+      (while (> (length co) 0)
+	(setq currword (car co))
+	(if (> (length currword) 1)
+	    (if (and (string-equal "\\" (substring currword 0 1))
+		     (not (string-match "[^a-zA-Z]" (substring currword 1)))
+		     (string-equal (downcase currword) currword))
+		(add-to-list 'wordlist currword)))
+	(if (string-equal "-" (car (setq co (cdr co))))
+	    (while (and (> (length co) 0)
+			(not (string-equal "-" (car (setq co (cdr co)))))))))
       wordlist))
   "LilyPond \\keywords")
 
 (defconst LilyPond-identifiers 
-  (let ((wordlist ())
+  (let ((wordlist '("\\voiceOne")) ; add \Identifiers to lilypond.words
 	(co (all-completions "" (LilyPond-add-dictionary-word ()))))
     (progn
       (while (> (length co) 0)
-	(if (> (length (car co)) 1)
-	    (if (and (string-equal "\\" (substring (car co) 0 1))
-		     (not (string-equal (downcase (car co)) (car co))))
-		(add-to-list 'wordlist (car co))))
-	(setq co (cdr co)))
+	(setq currword (car co))
+	(if (> (length currword) 1)
+	    (if (and (string-equal "\\" (substring currword 0 1))
+		     (not (string-match "[^a-zA-Z]" (substring currword 1)))
+		     (not (string-equal (downcase currword) currword)))
+		(add-to-list 'wordlist currword)))
+	(if (string-equal "-" (car (setq co (cdr co))))
+	    (while (and (> (length co) 0)
+			(not (string-equal "-" (car (setq co (cdr co)))))))))
       wordlist))
   "LilyPond \\Identifiers")
 
 (defconst LilyPond-reserved-words 
-  (let ((wordlist ())
+  (let ((wordlist '("Staff")) ; add ReservedWords to lilypond.words
 	(co (all-completions "" (LilyPond-add-dictionary-word ()))))
     (progn
       (while (> (length co) 0)
-	(if (> (length (car co)) 0)
-	    (if (not (string-equal "\\" (substring (car co) 0 1)))
-		(add-to-list 'wordlist (car co))))
-	(setq co (cdr co)))
+	(setq currword (car co))
+	(if (> (length currword) 0)
+	    (if (not (string-match "[^a-zA-Z]" currword))
+		(add-to-list 'wordlist currword)))
+	(if (string-equal "-" (car (setq co (cdr co))))
+	    (while (and (> (length co) 0)
+			(not (string-equal "-" (car (setq co (cdr co)))))))))
       wordlist))
   "LilyPond ReservedWords")
 
@@ -156,7 +189,6 @@ in LilyPond-include-path."
 
 (defun LilyPond-running ()
   "Check the currently running LilyPond compiling jobs."
-  (interactive)
   (let ((process-names (list "lilypond" "tex" "2dvi" "2ps" "2midi" 
 			     "book" "latex"))
 	(running nil))
@@ -169,7 +201,6 @@ in LilyPond-include-path."
 
 (defun LilyPond-midi-running ()
   "Check the currently running Midi processes."
-  (interactive)
   (let ((process-names (list "midi" "midiall"))
 	(running nil))
     (while (setq process-name (pop process-names))
@@ -203,7 +234,13 @@ in LilyPond-include-path."
 (defun LilyPond-compile-file (command name)
   ;; We maybe should know what we run here (Lily, ly2dvi, tex)
   ;; and adjust our error-matching regex ?
-  (compile-internal command "No more errors" name ))
+  (compile-internal
+   (if (eq LilyPond-command-current 'LilyPond-command-master)
+       command
+     ;; use temporary directory for Commands on Buffer/Region
+     ;; hm.. the directory is set twice, first to default-dir
+     (concat "cd " (LilyPond-temp-directory) "; " command))
+   "No more errors" name))
 
 ;; do we still need this, now that we're using compile-internal?
 (defun LilyPond-save-buffer ()
@@ -287,18 +324,21 @@ in LilyPond-include-path."
 
 (defun count-midi-words ()
   "Check number of midi-scores before the curser."
-  (interactive)
-  (count-rexp (point-min) (point-max) "\\\\midi"))
+  (if (eq LilyPond-command-current 'LilyPond-command-region)
+      (count-rexp (mark t) (point) "\\\\midi")
+    (count-rexp (point-min) (point-max) "\\\\midi")))
  
 (defun count-midi-words-backwards ()
   "Check number of midi-scores before the curser."
-  (interactive)
-  (count-rexp (point-min) (point) "\\\\midi"))
+  (if (eq LilyPond-command-current 'LilyPond-command-region)
+      (count-rexp (mark t) (point) "\\\\midi")
+    (count-rexp (point-min) (point) "\\\\midi")))
  
 (defun LilyPond-string-current-midi ()
   "Check the midi file of the following midi-score in the current document."
-  (interactive)
-  (let ((fnameprefix (substring (LilyPond-master-file) 0 -3)) ; suppose ".ly"
+  (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master)
+			 (substring (LilyPond-master-file) 0 -3); suppose ".ly"
+		       LilyPond-region-file-prefix))
 	(allcount (string-to-number (substring (count-midi-words) 0 -12)))
 	(count (string-to-number (substring (count-midi-words-backwards) 0 -12))))
     (concat  fnameprefix
@@ -310,8 +350,9 @@ in LilyPond-include-path."
 
 (defun LilyPond-string-all-midi ()
   "Return the midi files of the current document in ascending order."
-  (interactive)
-  (let ((fnameprefix (substring (LilyPond-master-file) 0 -3))
+  (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master)
+			 (substring (LilyPond-master-file) 0 -3); suppose ".ly"
+		       LilyPond-region-file-prefix))
 	(allcount (string-to-number (substring (count-midi-words) 0 -12))))
     (concat (if (> allcount 0)  ; at least one midi-score
 		(concat fnameprefix ".midi "))
@@ -367,10 +408,10 @@ LilyPond-expand-list.
 			(string :tag "Next Key")))))
 
 ;; drop this?
-(defcustom LilyPond-file-extensions '(".ly" ".sly" ".fly")
-  "*File extensions used by manually generated TeX files."
+(defcustom LilyPond-file-extension ".ly"
+  "*File extension used in LilyPond sources."
   :group 'LilyPond
-  :type '(repeat (string :format "%v")))
+  :type 'string)
 
 
 (defcustom LilyPond-expand-alist 
@@ -420,10 +461,10 @@ Must be the car of an entry in `LilyPond-command-alist'."
 
 (defun LilyPond-command-query (name)
   "Query the user for what LilyPond command to use."
-  (let* ((default (cond ((if (string-equal name "emacs-lily")
+  (let* ((default (cond ((if (string-equal name LilyPond-region-file-prefix)
 			     (LilyPond-check-files (concat name ".tex")
 						   (list name)
-						   LilyPond-file-extensions)
+						   (list LilyPond-file-extension))
 			   (if (verify-visited-file-modtime (current-buffer))
 			       (if (buffer-modified-p)
 				   (if (y-or-n-p "Save buffer before next command? ")
@@ -451,6 +492,7 @@ Must be the car of an entry in `LilyPond-command-alist'."
 (defun LilyPond-command-master ()
   "Run command on the current document."
   (interactive)
+  (LilyPond-command-select-master)
   (LilyPond-command (LilyPond-command-query (LilyPond-master-file))
 		    'LilyPond-master-file))
 
@@ -472,6 +514,12 @@ Must be the car of an entry in `LilyPond-command-alist'."
   (LilyPond-command (LilyPond-command-menu "2PS") 'LilyPond-master-file)
 )
 
+(defun LilyPond-command-formatmidi ()
+  "Format the midi output of the current document."
+  (interactive)
+  (LilyPond-command (LilyPond-command-menu "2Midi") 'LilyPond-master-file)
+)
+
 (defun LilyPond-command-smartview ()
   "View the dvi output of current document."
   (interactive)
@@ -490,38 +538,33 @@ Must be the car of an entry in `LilyPond-command-alist'."
   (LilyPond-command (LilyPond-command-menu "ViewPS") 'LilyPond-master-file)
 )
 
-;; FIXME, does not find commend ender
-(defun LilyPond-un-comment-region (start end level)
-  "Remove up to LEVEL comment characters from each line in the region."
-  (interactive "*r\np") 
-  (comment-region start end (- level)))
-
 ;; FIXME, this is broken
 (defun LilyPond-region-file (begin end)
   (let (
-	;; (dir "/tmp/")
-	;; urg
-	(dir "./")
-	(base "emacs-lily")
-	;; Hmm
-	(ext (if (string-match "^[\\]score" (buffer-substring begin end))
-		 ".ly"
-	       (if (< 50 (abs (- begin end)))
-		   ".fly"
-		 ".sly"))))
+	;; (dir "./")
+ 	(dir (LilyPond-temp-directory))
+	(base LilyPond-region-file-prefix)
+	(ext LilyPond-file-extension))
     (concat dir base ext)))
 
+;;; Commands on Region work if there is an appropriate '\score'.
 (defun LilyPond-command-region (begin end)
   "Run LilyPond on the current region."
   (interactive "r")
+  (if (or (> begin (point-min)) (< end (point-max)))
+      (LilyPond-command-select-region))
   (write-region begin end (LilyPond-region-file begin end) nil 'nomsg)
   (LilyPond-command (LilyPond-command-query
 		     (LilyPond-region-file begin end))
-		    '(lambda () (LilyPond-region-file begin end))))
+		    '(lambda () (LilyPond-region-file begin end)))
+  ;; Region may deactivate even if buffer was intact, reactivate?
+  ;; Currently, also deactived regions are used.
+  )
 
 (defun LilyPond-command-buffer ()
   "Run LilyPond on buffer."
   (interactive)
+  (LilyPond-command-select-buffer)
   (LilyPond-command-region (point-min) (point-max)))
 
 (defun LilyPond-command-expand (string file)
@@ -568,8 +611,9 @@ command."
 						(apply file nil)))
 	      (jobs nil)
 	      (job-string "no jobs"))
-	  (if (string-equal name "View")
-	      (let ((buffer-xdvi (get-buffer-create "*view*")))
+	  (if (member name (list "View" "ViewPS"))
+	      ;; is USR1 a right signal for viewps?
+	      (let ((buffer-xdvi (get-buffer-create (concat "*" name "*"))))
 		(if LilyPond-kick-xdvi
 		  (let ((process-xdvi (get-buffer-process buffer-xdvi)))
 		    (if process-xdvi
@@ -586,6 +630,16 @@ command."
 		  (progn
 		    (setq command (concat LilyPond-all-midi-command " " (LilyPond-string-all-midi)))
 		    (LilyPond-kill-midi))) ; stop and start playing
+	      (if (and (member name (list "Midi" "MidiAll")) job-string)
+		  (if (file-newer-than-file-p
+		       (LilyPond-master-file)
+		       (concat (substring (LilyPond-master-file) 0 -3) ".midi"))
+		      (if (y-or-n-p "Midi older than source. Reformat midi?")
+			  (progn
+			    (LilyPond-command-formatmidi)
+			    (while (LilyPond-running)
+			      (message "Starts playing midi once it is built.")
+			      (sit-for 0 100))))))
 	      (if (member name (list "LilyPond" "TeX" "2Midi" "2PS" "2Dvi" 
 				     "Book" "LaTeX"))
 		  (if (setq jobs (LilyPond-running))
@@ -598,21 +652,25 @@ command."
 			    (progn
 			      (setq job-string "no jobs")
 			      (LilyPond-kill-jobs)
-			      (sit-for 0 500 nil)) ; should wait killing
+			      (while (LilyPond-running)
+				(sit-for 0 100)))
 			  (setq job-string nil)))))
 
 	      (setq LilyPond-command-default name)
 	      (if (string-equal job-string "no jobs")
 		  (LilyPond-compile-file command name))))))))
 	  
-;; XEmacs stuff
-;; Sadly we need this for a macro in Emacs 19.
-(eval-when-compile
-  ;; Imenu isn't used in XEmacs, so just ignore load errors.
-  (condition-case ()
-      (require 'imenu)
-    (error nil)))
+(defun LilyPond-mark-active ()
+  "Check if there is an active mark."
+  (and transient-mark-mode
+       (if (string-match "XEmacs\\|Lucid" emacs-version) (mark) mark-active)))
 
+(defun LilyPond-temp-directory ()
+  "Temporary file directory for Commands on Region."
+  (interactive)
+  (if (string-match "XEmacs\\|Lucid" emacs-version)
+      (concat (temp-directory) "/")
+    temporary-file-directory))
 
 ;;; Keymap
 
@@ -628,12 +686,13 @@ command."
 (if LilyPond-mode-map
     ()
   (setq LilyPond-mode-map (make-sparse-keymap))
-  ;; Put keys to Lilypond-command-alist and fetch them from there somehow.
+  ;; Put keys to LilyPond-command-alist and fetch them from there somehow.
   (define-key LilyPond-mode-map "\C-c\C-l" 'LilyPond-command-lilypond)
   (define-key LilyPond-mode-map "\C-c\C-r" 'LilyPond-command-region)
   (define-key LilyPond-mode-map "\C-c\C-b" 'LilyPond-command-buffer)
   (define-key LilyPond-mode-map "\C-c\C-k" 'LilyPond-kill-jobs)
   (define-key LilyPond-mode-map "\C-c\C-c" 'LilyPond-command-master)
+  (define-key LilyPond-mode-map "\C-cm" 'LilyPond-command-formatmidi)
   (define-key LilyPond-mode-map "\C-c\C-d" 'LilyPond-command-formatdvi)
   (define-key LilyPond-mode-map "\C-c\C-f" 'LilyPond-command-formatps)
   (define-key LilyPond-mode-map "\C-c\C-s" 'LilyPond-command-smartview)
@@ -643,120 +702,42 @@ command."
   (define-key LilyPond-mode-map [(control c) (control return)] 'LilyPond-command-all-midi)
   (define-key LilyPond-mode-map "\C-x\C-s" 'LilyPond-save-buffer)
   (define-key LilyPond-mode-map "\C-cf" 'font-lock-fontify-buffer)
-  (define-key LilyPond-mode-map "\C-ci" 'LilyPond-quick-note-insert)
-  (define-key LilyPond-mode-map "\C-cn" 'LilyPond-insert-tag-notes)
-  (define-key LilyPond-mode-map "\C-cs" 'LilyPond-insert-tag-score)
-  (define-key LilyPond-mode-map "\C-c:" 'LilyPond-un-comment-region)
-  (define-key LilyPond-mode-map "\C-c;" 'comment-region)
-  (define-key LilyPond-mode-map ")" 'LilyPond-electric-close-paren) ; urgh
-  (define-key LilyPond-mode-map ">" 'LilyPond-electric-close-paren) ; argh
-  (define-key LilyPond-mode-map "}" 'LilyPond-electric-close-paren) ; ..rgh
-  (define-key LilyPond-mode-map [S-iso-lefttab] 'LilyPond-autocompletion)
+  (define-key LilyPond-mode-map "\C-ci" 'LilyPond-insert-tag-current)
+  ;; the following will should be overriden by Lilypond Quick Insert Mode
+  (define-key LilyPond-mode-map "\C-cq" 'LilyPond-quick-insert-mode)
+  (define-key LilyPond-mode-map "\C-c;" 'LilyPond-comment-region)
+  (define-key LilyPond-mode-map ")" 'LilyPond-electric-close-paren)
+  (define-key LilyPond-mode-map ">" 'LilyPond-electric-close-paren)
+  (define-key LilyPond-mode-map "}" 'LilyPond-electric-close-paren)
+  (define-key LilyPond-mode-map "]" 'LilyPond-electric-close-paren)
+  (if (string-match "XEmacs\\|Lucid" emacs-version)
+      (define-key LilyPond-mode-map [iso-left-tab] 'LilyPond-autocompletion)
+    (define-key LilyPond-mode-map [iso-lefttab] 'LilyPond-autocompletion))
   (define-key LilyPond-mode-map "\C-c\t" 'LilyPond-info-index-search)
   )
 
 ;;; Menu Support
 
-(defun LilyPond-quick-note-insert()
+;;; This mode was originally LilyPond-quick-note-insert by Heikki Junes.
+;;; The original version has been junked since CVS-1.97,
+;;; in order to merge the efforts done by Nicolas Sceaux.
+;;; LilyPond Quick Insert Mode is a major mode, toggled by C-c q.
+(defun LilyPond-quick-insert-mode ()
   "Insert notes with fewer key strokes by using a simple keyboard piano."
   (interactive)
-  (setq dutch-notes
-	'(("k" "a") ("l" "b") ("a" "c") ("s" "d") 
-	  ("d" "e") ("f" "f") ("j" "g") ("r" "r")))
-  (setq dutch-note-ends '("eses" "es" "" "is" "isis"))
-  (setq dutch-note-replacements '("" ""))
-  (setq finnish-note-replacements
-	'(("eeses" "eses") ("ees" "es") ("aeses" "asas") ("aes" "as") ("b" "h")
-	  ("beses" "heses") ("bes" "b") ("bis" "his") ("bisis" "hisis")))
-			      ; add more translations of the note names
-  (setq spanish-note-replacements
-	'(("c" "do") ("d" "re") ("e" "mi") ("f" "fa") ("g" "sol") ("a" "la") ("b" "si")
-      ("cis" "dos") ("cisis" "doss") ("ces" "dob") ("ceses" "dobb")
-      ("dis" "res") ("disis" "ress") ("des" "reb") ("deses" "rebb")
-      ("eis" "mis") ("eisis" "miss") ("ees" "mib") ("eeses" "mibb")
-      ("fis" "fas") ("fisis" "fass") ("fes" "fab") ("feses" "fabb")
-      ("gis" "sols") ("gisis" "solss") ("ges" "solb") ("geses" "solbb")
-      ("ais" "las") ("aisis" "lass") ("aes" "lab") ("aeses" "labb")
-      ("bis" "sis") ("bisis" "siss") ("bes" "sib") ("beses" "sibb")))
-  (setq other-keys "()<>~}")
-  (setq accid 0) (setq octav 0) (setq durat "") (setq dots 0)
-
-  (message "Press h for help.") (sit-for 0 750 1)
-
-  (setq note-replacements dutch-note-replacements)
-  (while (not (= 27 ; esc to quit
-    (setq x (read-char-exclusive 
-	     (format " | a[_]s[_]d | f[_]j[_]k[_]l | r with ie ,' 12345678 . 0 (<~>)/}\\b\\n Esc \n | c | d | e | f | g | a | %s | r with %s%s%s%s"
-		     (if (string= (car(cdr(assoc "b" note-replacements))) "h")
-			 "h" "b")
-		     (nth (+ accid 2) dutch-note-ends)
-		     (make-string (abs octav) (if (> octav 0) ?' ?,)) 
-		     durat 
-		     (if (string= durat "") "" (make-string dots ?.)))))))
-    ;; (insert (number-to-string x)) ; test numbers for characters
-    (setq note (cdr (assoc (char-to-string x) dutch-notes)))
-    (cond
-     ((= x 127) (backward-kill-word 1)) ; backspace
-     ((= x 13) (progn (insert "\n") (LilyPond-indent-line)))) ; return
-    (setq x (char-to-string x))
-    (cond
-     ((and (string< x "9") (string< "0" x))
-      (progn (setq durat (int-to-string (expt 2 (- (string-to-int x) 1))))
-	     (setq dots 0)))
-     ((string= x " ") (insert " "))
-     ((string= x "/") (progn (insert "\\times ")
-			     (while (not (and (string< x "9") (string< "0" x)))
-			       (setq x (char-to-string (read-char-exclusive "Insert a number for the denominator (\"x/\")"))))
-			     (insert (format "%s/" x)) (setq x "/")
-			     (while (not (and (string< x "9") (string< "0" x)))
-			       (setq x (char-to-string (read-char-exclusive "Insert a number for the numerator (\"/y\")"))))
-			     (insert (format "%s { " x))))
-     ((string= x "0") (progn (setq accid 0) (setq octav 0) 
-			     (setq durat "") (setq dots 0)))
-     ((string= x "i") (setq accid (if (= accid 2) 0 (max (+ accid 1) 1))))
-     ((string= x "e") (setq accid (if (= accid -2) 0 (min (+ accid -1) -1))))
-     ((string= x "'") (setq octav (if (= octav 4) 0 (max (+ octav 1) 1))))
-     ((string= x ",") (setq octav (if (= octav -4) 0 (min (+ octav -1) -1))))
-     ((string= x ".") (setq dots (if (= dots 4) 0 (+ dots 1))))
-     ((not (null (member x (split-string other-keys ""))))
-      (insert (format "%s " x)))
-     ((not (null note))
-      (progn
-	(setq note 
-	      (format "%s%s" (car note) (if (string= "r" (car note)) "" 
-					  (nth (+ accid 2) dutch-note-ends))))
-	(setq notetwo (car (cdr (assoc note note-replacements))))
-	(if (not (null notetwo)) (setq note notetwo))
-	(insert
-	 (format "%s%s%s%s " 
-		 note
-		 (if (string= "r" note) ""
-		     (make-string (abs octav) (if (> octav 0) ?' ?,)))
-		 durat
-		 (if (string= durat "") "" (make-string dots ?.))))
-	(setq accid 0) (setq octav 0) (setq durat "") (setq dots 0)))
-     ((string= x "t") (progn (setq note-replacements dutch-note-replacements)
-			     (message "Selected Dutch notes") 
-			     (sit-for 0 750 1))) ; t
-     ((string= x "n") (progn (setq note-replacements finnish-note-replacements)
-			     (message "Selected Finnish/Deutsch notes") 
-			     (sit-for 0 750 1))) ; n
-			      ; add more translations of the note names
-     ((string= x "p") (progn (setq note-replacements spanish-note-replacements)
-			     (message "Selected Spanish notes") 
-			     (sit-for 0 750 1))) ; p
-     ((string= x "h") 
-      (progn (message "Insert notes with fewer key strokes. For example \"i,5.f\" produces \"fis,32. \".") (sit-for 5 0 1) 
-	     (message "Add also \"a ~ a\"-ties, \"a ( ) b\"-slurs and \"< a b >\"-chords.") (sit-for 5 0 1) 
-	     (message "Note names are in Du(t)ch by default. Hit 'n' for Fin(n)ish/Deutsch note names. Hit 'p' for S(p)anish note names") (sit-for 5 0 1) 
-	     (message "Backspace deletes last note, return starts a new indented line and Esc quits.") (sit-for 5 0 1) 
-	     (message "Insert note triplets \"\\times 2/3 { a b } \" by typing \"/23ab}\".") (sit-for 5 0 1) 
-	     (message "Remember to add all other details as well.") (sit-for 5 0 1)))
-    )))
+  (progn 
+    (message "Invoke (C-c q) from keyboard. If you still see this message,") (sit-for 5 0)
+    (message "then you have not installed LilyPond Quick Insert Mode (lyqi).") (sit-for 5 0)
+    (message "Download lyqi from http://nicolas.sceaux.free.fr/lilypond/lyqi.html,") (sit-for 5 0)
+    (message "see installation instructions from lyqi's README -file.") (sit-for 5 0)
+    (message "You need also eieio (Enhanced Integration of Emacs Interpreted Objects).") (sit-for 5 0)
+    (message "Download eieio from http://cedet.sourceforge.net/eieio.shtml,") (sit-for 5 0)
+    (message "see installation instructions from eieio's INSTALL -file.") (sit-for 5 0)
+    (message "")
+    ))    
 
 (defun LilyPond-pre-word-search ()
   "Fetch the alphabetic characters and \\ in front of the cursor."
-  (interactive)
   (let ((pre "")
 	(prelen 0)
 	(ch (char-before (- (point) 0))))
@@ -770,7 +751,6 @@ command."
 
 (defun LilyPond-post-word-search ()
   "Fetch the alphabetic characters behind the cursor."
-  (interactive)
   (let ((post "")
 	(postlen 0)
 	(ch (char-after (+ (point) 0))))
@@ -806,7 +786,7 @@ command."
 	  (setq compsstr (concat compsstr "\"" (car complist) "\" "))
 	  (setq complist (cdr complist)))
 	(message compsstr) 
-	(sit-for 0 100 1)))))
+	(sit-for 0 100)))))
 
 (defun LilyPond-info ()
   "Launch Info for lilypond."
@@ -824,7 +804,7 @@ command."
   (info "lilypond-internals"))
   
 (defun LilyPond-info-index-search ()
-  "Inside Emacs, launch `info lilypond --index-search word-under-cursor'"
+  "In `*info*'-buffer, launch `info lilypond --index-search word-under-cursor'"
   (interactive)
   (let ((str (concat (LilyPond-pre-word-search) (LilyPond-post-word-search))))
     (if (and (> (length str) 0) 
@@ -833,63 +813,69 @@ command."
     (LilyPond-info)
     (Info-index str)))
 
-(defun LilyPond-insert-string (pre)
-  "Insert text to the buffer."
-  (interactive)
-  (insert pre)
-  (length pre))
-
-(defun LilyPond-insert-between (text pre post)
-  "Insert text to the buffer if non-empty string is given."
-  (interactive)
-  (let ((str (read-string text)))
-    (if (string-equal str "")
-	0
-      (progn (setq pre_str_post (concat pre str post))
-	     (insert pre_str_post)
-	     (length pre_str_post)))))
-
-(defun LilyPond-insert-tag-notes ()
-  "LilyPond notes tag."
+(defun LilyPond-insert-tag-current (&optional word)
+  "Set the current tag to be inserted."
   (interactive)
-  (setq begin (if (and transient-mark-mode mark-active) 
-		  (mark-marker) (point-marker)))
-  (setq end (point-marker))
-  (goto-char begin)
-  (setq l1 (LilyPond-insert-string "\\notes "))
-  (setq l2 (LilyPond-insert-between "Relative (e.g. c'): " "\\relative " " "))
-  (if (eq l2 0)
-      (setq l2 (LilyPond-insert-between "Transpose (e.g. c c'): " "\\transpose " " ")))
-  (setq l3 (LilyPond-insert-string "{ "))
-  (goto-char (+ end l1 l2 l3))
-  (LilyPond-insert-string " }")
-  (goto-char (+ end l1 l2 l3)))
-
-(defun LilyPond-insert-tag-score ()
-  "LilyPond score tag."
+  (if word
+      (setq LilyPond-insert-tag-current word))
+  (if (memq LilyPond-insert-tag-current LilyPond-menu-keywords)
+      (LilyPond-insert-tag)
+    (message "No tag was selected from LilyPond->Insert tag-menu.")))
+
+(defun LilyPond-insert-tag ()
+  "Insert syntax for given tag. The definitions are in lilypond.words."
   (interactive)
-  (setq begin (if (and transient-mark-mode mark-active) 
-		  (mark-marker) (point-marker)))
-  (setq end (point-marker))
-  (goto-char begin)
-  (setq l1 (LilyPond-insert-string "\\score {\n    ")) ; keep track of lengths
-  (goto-char (+ end l1))
-  (LilyPond-insert-string "\n    \\paper { }\n")
-  (setq l2 (if (y-or-n-p "Insert \"\\header\" field? ")
-	       (+ (LilyPond-insert-string "    \\header {")
-		  (LilyPond-insert-between "Title: " "\n      title = \"" "\"")
-		  (LilyPond-insert-between "Subtitle: " "\n      subtitle = \"" "\"")
-		  (LilyPond-insert-between "Piece: " "\n      piece = \"" "\"")
-		  (LilyPond-insert-between "Opus: "  "\n      opus = \"" "\"")
-		  (LilyPond-insert-string "\n    }\n"))
-	     0))
-  (setq l3 (if (y-or-n-p "Insert \"\\midi\" field? ")
-	       (+ (LilyPond-insert-string "    \\midi {")
-		  (LilyPond-insert-between "Tempo: " " \\tempo (e.g. 4 = 60)" "")
-		  (LilyPond-insert-string " }\n"))
-	     0))
-  (setq l4 (LilyPond-insert-string "}\n"))
-  (goto-char (+ end l1)))
+  (setq b (find-file-noselect (LilyPond-words-filename) t t))
+  (let ((word LilyPond-insert-tag-current)
+	(found nil)
+	(p nil)
+	(query nil)
+        (m (set-marker (make-marker) 1 (get-buffer b)))
+        (distance (if (LilyPond-mark-active)
+		      (abs (- (mark-marker) (point-marker))) 0))
+       )
+   ;; find the place first
+   (if (LilyPond-mark-active)
+       (goto-char (min (mark-marker) (point-marker))))
+   (while (and (not found) (> (buffer-size b) (marker-position m)))
+    (setq copy (car (copy-alist (list (eval (symbol-name (read m)))))))
+    (if (string-equal word copy) (setq found t)))
+   (if found (insert word))
+   (if (> (buffer-size b) (marker-position m))
+       (setq copy (car (copy-alist (list (eval (symbol-name (read m))))))))
+   (if (not (string-equal "-" copy)) 
+       (setq found nil))
+   (while (and found (> (buffer-size b) (marker-position m)))
+    ;; find next symbol
+    (setq copy (car (copy-alist (list (eval (symbol-name (read m)))))))
+    ;; check whether it is the word, or the word has been found
+    (cond 
+     ((string-equal "-" copy) (setq found nil))
+     ((string-equal "%" copy) (insert " " (read-string "Give Arguments: ")))
+     ((string-equal "_" copy) 
+      (progn 
+       (setq p (point))
+       (goto-char (+ p distance))))
+     ((string-equal "\?" copy) (setq query t))
+     ((string-equal "\!" copy) (setq query nil))
+     ((string-equal "\\n" copy) 
+      (if (not query)
+       (progn (LilyPond-indent-line) (insert "\n") (LilyPond-indent-line))))
+     ((string-equal "{" copy) 
+      (if (not query) 
+	  (progn (insert " { "))))
+     ((string-equal "}" copy)
+      (if (not query)
+       (progn (insert " } ") (setq query nil) )))
+     ((not query)
+      (insert copy))
+     (query
+      (if (y-or-n-p (concat "Proceed with `" copy "'? "))
+       (progn (insert copy) (setq query nil))))
+   ))
+   (if p (goto-char p))
+   (kill-buffer b))
+)
 
 (defun LilyPond-command-menu-entry (entry)
   ;; Return LilyPond-command-alist ENTRY as a menu item.
@@ -922,12 +908,12 @@ command."
 ;;;	  (let ((file 'LilyPond-command-on-current))
 ;;;	    (mapcar 'LilyPond-command-menu-entry LilyPond-command-alist))
 ;;; Some kind of mapping which includes :keys might be more elegant
-;;; Put keys to Lilypond-command-alist and fetch them from there somehow.
+;;; Put keys to LilyPond-command-alist and fetch them from there somehow.
 	  '([ "LilyPond" LilyPond-command-lilypond t])
 	  '([ "TeX" (LilyPond-command (LilyPond-command-menu "TeX") 'LilyPond-master-file) ])
 	  '([ "2Dvi" LilyPond-command-formatdvi t])
 	  '([ "2PS" LilyPond-command-formatps t])
-	  '([ "2Midi" (LilyPond-command (LilyPond-command-menu "2Midi") 'LilyPond-master-file)])
+	  '([ "2Midi" LilyPond-command-formatmidi t])
 	  '([ "Book" (LilyPond-command (LilyPond-command-menu "Book") 'LilyPond-master-file) ])
 	  '([ "LaTeX" (LilyPond-command (LilyPond-command-menu "LaTeX") 'LilyPond-master-file) ])
 	  '([ "Kill jobs" LilyPond-kill-jobs t])
@@ -940,20 +926,49 @@ command."
 	  '([ "Midi all" LilyPond-command-all-midi t])
 	  ))
 
+(defun LilyPond-menu-keywords-item (arg)
+  "Make vector for LilyPond-mode-keywords."
+  (vector arg (list 'LilyPond-insert-tag-current arg) :style 'radio :selected (list 'eq 'LilyPond-insert-tag-current arg)))
+
+(defun LilyPond-menu-keywords ()
+  "Make Insert Tag menu. 
+
+The Insert Tag -menu is splitted into parts if it is long enough."
+
+  (let ((li (mapcar 'LilyPond-menu-keywords-item LilyPond-menu-keywords))
+	(w (round (sqrt (length LilyPond-menu-keywords))))
+	(splitted '())
+	(imin 0) imax lw rw)
+    (while (< imin (length LilyPond-menu-keywords))
+      (setq imax (- (min (+ imin w) (length LilyPond-menu-keywords)) 1))
+      (setq lw (nth imin LilyPond-menu-keywords)) 
+      (setq rw (nth imax LilyPond-menu-keywords))
+      (add-to-list 'splitted
+         (let ((l (list (concat (substring lw 0 (min 7 (length lw))) 
+				" ... " 
+				(substring rw 0 (min 7 (length rw)))))))
+	   (while (<= imin imax)
+	     (add-to-list 'l (nth imin li))
+	     (setq imin (1+ imin)))
+	   (reverse l))))
+    (if (> (length LilyPond-menu-keywords) 12) (reverse splitted) li)))
+
+;;; LilyPond-mode-menu should not be interactive, via "M-x LilyPond-<Tab>"
 (easy-menu-define LilyPond-mode-menu
   LilyPond-mode-map
   "Menu used in LilyPond mode."
   (append '("LilyPond")
-	  '(("Insert"
-	     [ "\\notes..."  LilyPond-insert-tag-notes t]
-	     [ "\\score..."  LilyPond-insert-tag-score t]
-	     ["Quick Notes"  LilyPond-quick-note-insert t]
-	     ["Autocompletion"   LilyPond-autocompletion t]
-	     ))
+	  '(["Add index menu" LilyPond-add-imenu-menu])
+	  (list (cons "Insert tag" 
+                (cons ["Previously selected" LilyPond-insert-tag-current t] 
+                (cons "-----"
+		      (LilyPond-menu-keywords)))))
 	  '(("Miscellaneous"
-	     ["Uncomment Region" LilyPond-un-comment-region t]
-	     ["Comment Region" comment-region t]
+	     ["Autocompletion"   LilyPond-autocompletion t]
+	     ["(Un)comment Region" LilyPond-comment-region t]
 	     ["Refontify buffer" font-lock-fontify-buffer t]
+	     "-----"
+	     ["Quick Insert Mode"  LilyPond-quick-insert-mode :keys "C-c q"]
  	     ))
 	  '(("Info"
 	     ["LilyPond" LilyPond-info t]
@@ -988,7 +1003,24 @@ command."
 (defun LilyPond-command-menu (name)
   ;; Execute LilyPond-command-alist NAME from a menu.
   (let ((LilyPond-command-force name))
-    (funcall LilyPond-command-current)))
+    (if (eq LilyPond-command-current 'LilyPond-command-region)
+	(if (eq (mark t) nil)
+	    (progn (message "The mark is not set now") (sit-for 0 500))
+	  (progn (if (not (not (LilyPond-mark-active)))
+		     (progn (message "Region is not active, using region between inactive mark and current point.") (sit-for 0 500)))
+		 (LilyPond-command-region (mark t) (point))))
+      (funcall LilyPond-command-current))))
+
+(defun LilyPond-add-imenu-menu ()
+  (interactive)
+  "Add an imenu menu to the menubar."
+  (if (not LilyPond-imenu)
+      (progn
+	(imenu-add-to-menubar "Index")
+	(redraw-frame (selected-frame))
+	(setq LilyPond-imenu t))
+    (message "%s" "LilyPond-imenu already exists.")))
+(put 'LilyPond-add-imenu-menu 'menu-enable '(not LilyPond-imenu))
 
 (defun LilyPond-mode ()
   "Major mode for editing LilyPond music files.
@@ -1043,15 +1075,44 @@ LilyPond-xdvi-command\t\tcommand to display dvi files -- bit superfluous"
   (make-local-variable 'indent-line-function)
   (setq indent-line-function 'LilyPond-indent-line)
 
-  (set-syntax-table LilyPond-mode-syntax-table)
+  (LilyPond-mode-set-syntax-table '(?\< ?\> ?\{ ?\}))
   (setq major-mode 'LilyPond-mode)
   (setq mode-name "LilyPond")
   (setq local-abbrev-table LilyPond-mode-abbrev-table)
   (use-local-map LilyPond-mode-map)
 
+  ;; In XEmacs imenu was synched up with: FSF 20.4
   (make-local-variable 'imenu-generic-expression)
   (setq imenu-generic-expression LilyPond-imenu-generic-expression)
-  (imenu-add-to-menubar "Index")
+  ;; (imenu-add-to-menubar "Index") ; see LilyPond-add-imenu-menu
+
+  ;; In XEmacs one needs to use 'easy-menu-add'.
+  (if (string-match "XEmacs\\|Lucid" emacs-version)
+      (progn
+	(easy-menu-add LilyPond-mode-menu)
+	(easy-menu-add LilyPond-command-menu)))
+
+  ;; Use Command on Region even for inactive mark (region).
+  (if (string-match "XEmacs\\|Lucid" emacs-version)
+      (setq zmacs-regions nil)
+    (setq mark-even-if-inactive t))
+
+  ;; Context dependent syntax tables in LilyPond-mode
+  (make-local-hook 'post-command-hook) ; XEmacs requires
+  (add-hook 'post-command-hook 'LilyPond-mode-context-set-syntax-table nil t)
+
+  ;; Turn on paren-mode buffer-locally, i.e., in LilyPond-mode
+  (if (string-match "XEmacs\\|Lucid" emacs-version)
+      (progn
+	(make-local-variable 'paren-mode)
+	(paren-set-mode 'paren)
+	(make-local-variable 'blink-matching-paren)
+	(setq blink-matching-paren t)
+	)
+    (progn
+      (make-local-variable 'blink-matching-paren-on-screen)
+      (setq blink-matching-paren-on-screen t)
+     ))
 
   ;; run the mode hook. LilyPond-mode-hook use is deprecated
   (run-hooks 'LilyPond-mode-hook))