]> git.donarmstrong.com Git - lilypond.git/blob - elisp/lilypond-mode.el
(set_spacing_rods): rewrite to O(n)
[lilypond.git] / elisp / lilypond-mode.el
1 ;;;
2 ;;; lilypond-mode.el --- Major mode for editing GNU LilyPond music scores
3 ;;;
4 ;;; source file of the GNU LilyPond music typesetter
5 ;;;  
6 ;;; (c) 1999--2005 Jan Nieuwenhuizen <janneke@gnu.org>
7 ;;; 
8 ;;; Changed 2001--2003 Heikki Junes <heikki.junes@hut.fi>
9 ;;;    * Add PS-compilation, PS-viewing and MIDI-play (29th Aug 2001)
10 ;;;    * Keyboard shortcuts (12th Sep 2001)
11 ;;;    * Inserting tags, inspired on sgml-mode (11th Oct 2001)
12 ;;;    * Autocompletion & Info (23rd Nov 2002)
13
14 ;;; Inspired on auctex
15
16 ;;; Look lilypond-init.el or Documentation/topdocs/INSTALL.texi
17 ;;; for installing instructions.
18
19 (require 'easymenu)
20 (require 'compile)
21
22 (defconst LilyPond-version "2.3.17"
23   "`LilyPond-mode' version number.")
24
25 (defconst LilyPond-help-address "bug-lilypond@gnu.org"
26   "Address accepting submission of bug reports.")
27
28 (defvar LilyPond-mode-hook nil
29   "*Hook called by `LilyPond-mode'.")
30
31 (defvar LilyPond-region-file-prefix "emacs-lily"
32   "File prefix for commands on buffer or region.")
33
34 (defvar LilyPond-master-file nil
35   "Master file that Lilypond will be run on.")
36
37 ;; FIXME: find ``\score'' in buffers / make settable?
38 (defun LilyPond-get-master-file ()
39   (or LilyPond-master-file
40       (buffer-file-name)))
41
42 (defvar LilyPond-kick-xdvi nil
43   "If true, no simultaneous xdvi's are started, but reload signal is sent.")
44
45 (defvar LilyPond-command-history nil
46   "Command history list.")
47         
48 (defvar LilyPond-regexp-alist
49   '(("\\([a-zA-Z]?:?[^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 2))
50   "Regexp used to match LilyPond errors.  See `compilation-error-regexp-alist'.")
51
52 (defvar LilyPond-imenu nil
53   "A flag to tell whether LilyPond-imenu is turned on.")
54 (make-variable-buffer-local 'LilyPond-imenu)
55
56 (defcustom LilyPond-include-path ".:/tmp"
57   "* LilyPond include path."
58   :type 'string
59   :group 'LilyPond)
60
61 (defun LilyPond-words-filename ()
62   "The file containing LilyPond \keywords \Identifiers and ReservedWords.
63 Finds file lilypond-words.el from load-path."
64   (let ((fn nil)
65         (lp load-path)
66         (words-file "lilypond-words.el"))
67     (while (and (> (length lp) 0) (not fn))
68       (setq fn (concat (car lp) "/" words-file))
69       (if (not (file-readable-p fn)) 
70           (progn (setq fn nil) (setq lp (cdr lp)))))
71     (if (not fn)
72         (progn (message "Warning: `lilypond-words.el' not found in `load-path'. See `lilypond-init.el'.")
73                (sit-for 5 0)))
74     fn))
75
76 (defun LilyPond-add-dictionary-word (x)
77   "Contains all words: \keywords \Identifiers and ReservedWords."
78   (nconc '(("" . 1)) x))
79
80 (if (> emacs-major-version 20)
81     (defun get-buffer-size (b) (buffer-size b))
82   (defun get-buffer-size (b)
83     (let (size (current-buffer (current-buffer)))
84       (set-buffer b)
85       (setq size (buffer-size))
86       (set-buffer current-buffer)
87       size
88     )))
89
90 ;; creates dictionary if empty
91 (if (and (eq (length (LilyPond-add-dictionary-word ())) 1)
92          (not (eq (LilyPond-words-filename) nil)))
93     (progn
94       (setq b (find-file-noselect (LilyPond-words-filename) t t))
95       (setq m (set-marker (make-marker) 1 (get-buffer b)))
96       (setq i 1)
97       (while (> (get-buffer-size b) (marker-position m))
98         (setq i (+ i 1))
99         (setq copy (copy-alist (list (eval (symbol-name (read m))))))
100         (setcdr copy i)
101         (LilyPond-add-dictionary-word (list copy)))
102       (kill-buffer b)))
103
104 (defvar LilyPond-insert-tag-current ""
105   "The last command selected from the LilyPond-Insert -menu.")
106
107 (defconst LilyPond-menu-keywords 
108   (let ((wordlist '())
109         (co (all-completions "" (LilyPond-add-dictionary-word ())))
110         (currword ""))
111     (progn
112       (while (> (length co) 0)
113         (setq currword (car co))
114         (if (string-equal "-" (car (setq co (cdr co))))
115             (progn
116               (add-to-list 'wordlist currword)
117               (while (and (> (length co) 0)
118                           (not (string-equal "-" (car (setq co (cdr co))))))))))
119       (reverse wordlist)))
120   "Keywords inserted from LilyPond-Insert-menu.")
121
122 (defconst LilyPond-keywords
123   (let ((wordlist '("\\score"))
124         (co (all-completions "" (LilyPond-add-dictionary-word ())))
125         (currword ""))
126     (progn
127       (while (> (length co) 0)
128         (setq currword (car co))
129         (if (> (length currword) 1)
130             (if (and (string-equal "\\" (substring currword 0 1))
131                      (string-match "[a-z-]+" currword)
132                      (= (match-beginning 0) 1)
133                      (= (match-end 0) (length currword))
134                      (not (string-equal "\\longa" currword))
135                      (not (string-equal "\\breve" currword))
136                      (not (string-equal "\\maxima" currword))
137                      (string-equal (downcase currword) currword))
138                 (add-to-list 'wordlist currword)))
139         (if (string-equal "-" (car (setq co (cdr co))))
140             (while (and (> (length co) 0)
141                         (not (string-equal "-" (car (setq co (cdr co)))))))))
142       (reverse wordlist)))
143   "LilyPond \\keywords")
144
145 (defconst LilyPond-identifiers 
146   (let ((wordlist '("\\voiceOne"))
147         (co (all-completions "" (LilyPond-add-dictionary-word ()))))
148     (progn
149       (while (> (length co) 0)
150         (setq currword (car co))
151         (if (> (length currword) 1)
152             (if (and (string-equal "\\" (substring currword 0 1))
153                      (string-match "[a-zA-Z-]+" currword)
154                      (= (match-beginning 0) 1)
155                      (= (match-end 0) (length currword))
156                      (not (string-equal (downcase currword) currword)))
157                 (add-to-list 'wordlist currword)))
158         (if (string-equal "-" (car (setq co (cdr co))))
159             (while (and (> (length co) 0)
160                         (not (string-equal "-" (car (setq co (cdr co)))))))))
161       (reverse wordlist)))
162   "LilyPond \\Identifiers")
163
164 (defconst LilyPond-Capitalized-Reserved-Words 
165   (let ((wordlist '("StaffContext"))
166         (co (all-completions "" (LilyPond-add-dictionary-word ()))))
167     (progn
168       (while (> (length co) 0)
169         (setq currword (car co))
170         (if (> (length currword) 0)
171             (if (and (string-match "[a-zA-Z_]+" currword)
172                      (= (match-beginning 0) 0)
173                      (= (match-end 0) (length currword))
174                      (not (string-equal (downcase currword) currword)))
175                 (add-to-list 'wordlist currword)))
176         (if (string-equal "-" (car (setq co (cdr co))))
177             (while (and (> (length co) 0)
178                         (not (string-equal "-" (car (setq co (cdr co)))))))))
179       (reverse wordlist)))
180   "LilyPond ReservedWords")
181
182 (defconst LilyPond-non-capitalized-reserved-words
183   (let ((wordlist '("cessess"))
184         (co (all-completions "" (LilyPond-add-dictionary-word ()))))
185     (progn
186       (while (> (length co) 0)
187         (setq currword (car co))
188         (if (> (length currword) 0)
189             (if (and (string-match "[a-z]+" currword)
190                      (= (match-beginning 0) 0)
191                      (= (match-end 0) (length currword))
192                      (string-equal (downcase currword) currword))
193                 (add-to-list 'wordlist currword)))
194         (if (string-equal "-" (car (setq co (cdr co))))
195             (while (and (> (length co) 0)
196                         (not (string-equal "-" (car (setq co (cdr co)))))))))
197       (reverse wordlist)))
198   "LilyPond notenames")
199
200 (defun LilyPond-check-files (derived originals extensions)
201   "Check that DERIVED is newer than any of the ORIGINALS.
202 Try each original with each member of EXTENSIONS, in all directories
203 in LilyPond-include-path."
204   (let ((found nil)
205         (regexp (concat "\\`\\("
206                         (mapconcat (function (lambda (dir)
207                                       (regexp-quote (expand-file-name dir))))
208                                    LilyPond-include-path "\\|")
209                         "\\).*\\("
210                         (mapconcat 'regexp-quote originals "\\|")
211                         "\\)\\.\\("
212                         (mapconcat 'regexp-quote extensions "\\|")
213                         "\\)\\'"))
214         (buffers (buffer-list)))
215     (while buffers
216       (let* ((buffer (car buffers))
217              (name (buffer-file-name buffer)))
218         (setq buffers (cdr buffers))
219         (if (and name (string-match regexp name))
220             (progn
221               (and (buffer-modified-p buffer)
222                    (or (not LilyPond-save-query)
223                        (y-or-n-p (concat "Save file "
224                                          (buffer-file-name buffer)
225                                          "? ")))
226                    (save-excursion (set-buffer buffer) (save-buffer)))
227               (if (file-newer-than-file-p name derived)
228                   (setq found t))))))
229     found))
230
231 (defun LilyPond-running ()
232   "Check the currently running LilyPond compiling jobs."
233   (let ((process-names (list "lilypond" "tex" "2dvi" "2ps" "2midi" 
234                              "book" "latex"))
235         (running nil))
236     (while (setq process-name (pop process-names))
237       (setq process (get-process process-name))
238       (if (and process 
239                (eq (process-status process) 'run))
240           (push process-name running)))
241     running)) ; return the running jobs
242
243 (defun LilyPond-midi-running ()
244   "Check the currently running Midi processes."
245   (let ((process-names (list "midi" "midiall"))
246         (running nil))
247     (while (setq process-name (pop process-names))
248       (setq process (get-process process-name))
249       (if (and process 
250                (eq (process-status process) 'run))
251           (push process-name running)))
252     running)) ; return the running jobs
253
254 (defun LilyPond-kill-jobs ()
255   "Kill the currently running LilyPond compiling jobs."
256   (interactive)
257   (let ((process-names (LilyPond-running))
258         (killed nil))
259     (while (setq process-name (pop process-names))
260       (quit-process (get-process process-name) t)
261       (push process-name killed))
262     killed)) ; return the killed jobs
263
264 (defun LilyPond-kill-midi ()
265   "Kill the currently running midi processes."
266   (let ((process-names (LilyPond-midi-running))
267         (killed nil))
268     (while (setq process-name (pop process-names))
269       (quit-process (get-process process-name) t)
270       (push process-name killed))
271     killed)) ; return the killed jobs
272
273 ;; URG, should only run LilyPond-compile for LilyPond
274 ;; not for tex,xdvi (lilypond?)
275 (defun LilyPond-compile-file (command name)
276   ;; We maybe should know what we run here (Lily, lilypond, tex)
277   ;; and adjust our error-matching regex ?
278   (compile-internal
279    (if (eq LilyPond-command-current 'LilyPond-command-master)
280        command
281      ;; use temporary directory for Commands on Buffer/Region
282      ;; hm.. the directory is set twice, first to default-dir
283      (concat "cd " (LilyPond-temp-directory) "; " command))
284    "No more errors" name))
285
286 ;; do we still need this, now that we're using compile-internal?
287 (defun LilyPond-save-buffer ()
288   "Save buffer and set default command for compiling."
289   (interactive)
290   (if (buffer-modified-p)
291       (progn (save-buffer)
292              (setq LilyPond-command-next LilyPond-command-default))))
293
294 ;;; return (dir base ext)
295 (defun split-file-name (name)
296   (let* ((i (string-match "[^/]*$" name))
297          (dir (if (> i 0) (substring name 0 i) "./"))
298          (file (substring name i (length name)))
299          (i (string-match "[^.]*$" file)))
300     (if (and
301          (> i 0)
302          (< i (length file)))
303         (list dir (substring file 0 (- i 1)) (substring file i (length file)))
304       (list dir file ""))))
305
306
307 ;; Should check whether in command-alist?
308 (defcustom LilyPond-command-default "LilyPond"
309   "Default command. Must identify a member of LilyPond-command-alist."
310
311   :group 'LilyPond
312   :type 'string)
313 ;;;(make-variable-buffer-local 'LilyPond-command-last)
314
315 (defvar LilyPond-command-next LilyPond-command-default)
316
317 (defvar LilyPond-command-current 'LilyPond-command-master)
318 ;;;(make-variable-buffer-local 'LilyPond-command-master)
319
320
321 ;; If non-nil, LilyPond-command-query will return the value of this
322 ;; variable instead of quering the user. 
323 (defvar LilyPond-command-force nil)
324
325 (defcustom LilyPond-xdvi-command "xdvi"
326   "Command used to display DVI files."
327
328   :group 'LilyPond
329   :type 'string)
330
331 (defcustom LilyPond-gv-command "gv -watch"
332   "Command used to display PS files."
333
334   :group 'LilyPond
335   :type 'string)
336
337 (defcustom LilyPond-midi-command "timidity"
338   "Command used to play MIDI files."
339
340   :group 'LilyPond
341   :type 'string)
342
343 (defcustom LilyPond-all-midi-command "timidity -ia"
344   "Command used to play MIDI files."
345
346   :group 'LilyPond
347   :type 'string)
348
349 (defun LilyPond-command-current-midi ()
350   "Play midi corresponding to the current document."
351   (interactive)
352   (LilyPond-command (LilyPond-command-menu "Midi") 'LilyPond-get-master-file))
353
354 (defun LilyPond-command-all-midi ()
355   "Play midi corresponding to the current document."
356   (interactive)
357   (LilyPond-command (LilyPond-command-menu "MidiAll") 'LilyPond-get-master-file))
358
359 (defun count-rexp (start end rexp)
360   "Print number of found regular expressions in the region."
361   (interactive "r")
362   (save-excursion
363     (save-restriction
364       (narrow-to-region start end)
365       (goto-char (point-min))
366       (count-matches rexp))))
367
368 (defun count-midi-words ()
369   "Check number of midi-scores before the curser."
370   (if (eq LilyPond-command-current 'LilyPond-command-region)
371       (count-rexp (mark t) (point) "\\\\midi")
372     (count-rexp (point-min) (point-max) "\\\\midi")))
373  
374 (defun count-midi-words-backwards ()
375   "Check number of midi-scores before the curser."
376   (if (eq LilyPond-command-current 'LilyPond-command-region)
377       (count-rexp (mark t) (point) "\\\\midi")
378     (count-rexp (point-min) (point) "\\\\midi")))
379  
380 (defun LilyPond-string-current-midi ()
381   "Check the midi file of the following midi-score in the current document."
382   (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master)
383                          (substring (LilyPond-get-master-file) 0 -3); suppose ".ly"
384                        LilyPond-region-file-prefix))
385         (allcount (string-to-number (substring (count-midi-words) 0 -12)))
386         (count (string-to-number (substring (count-midi-words-backwards) 0 -12))))
387     (concat  fnameprefix
388              (if (and (> allcount 1) (> count 0)) ; not first score
389                  (if (eq count allcount)          ; last score
390                      (concat "-" (number-to-string (+ count -1)))
391                    (concat "-" (number-to-string count))))
392              ".midi")))
393
394 (defun LilyPond-string-all-midi ()
395   "Return the midi files of the current document in ascending order."
396   (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master)
397                          (substring (LilyPond-get-master-file) 0 -3); suppose ".ly"
398                        LilyPond-region-file-prefix))
399         (allcount (string-to-number (substring (count-midi-words) 0 -12))))
400     (concat (if (> allcount 0)  ; at least one midi-score
401                 (concat fnameprefix ".midi "))
402             (if (> allcount 1)  ; more than one midi-score
403                 (concat fnameprefix "-[1-9].midi "))
404             (if (> allcount 9)  ; etc.
405                 (concat fnameprefix "-[1-9][0-9].midi"))
406             (if (> allcount 99) ; not first score
407                 (concat fnameprefix "-[1-9][0-9][0-9].midi")))))
408
409 ;; This is the major configuration variable.
410 (defcustom LilyPond-command-alist
411   ;; Should expand this to include possible keyboard shortcuts which
412   ;; could then be mapped to define-key and menu.
413   `(
414     ("LilyPond" . ("lilypond -ftex %s" "%s" "%l" "View"))
415     ("TeX" . ("tex '\\nonstopmode\\input %t'" "%t" "%d" "View"))
416
417     ("2Dvi" . ("lilypond -f tex %s" "%s" "%d" "LaTeX"))
418     ("2PS" . ("lilypond -f ps %s" "%s" "%p" "ViewPS"))
419     ("2Midi" . ("lilypond -m %s" "%s" "%m" "Midi"))
420
421     ("Book" . ("lilypond-book %x" "%x" "%l" "LaTeX"))
422     ("LaTeX" . ("latex '\\nonstopmode\\input %l'" "%l" "%d" "View"))
423
424     ;; point-n-click (arg: exits upop USR1)
425     ("SmartView" . ("xdvi %d"))
426
427     ;; refreshes when kicked USR1
428     ("View" . (,(concat LilyPond-xdvi-command " %d")))
429     ("ViewPS" . (,(concat LilyPond-gv-command " %p")))
430
431     ;; The following are refreshed in LilyPond-command:
432     ;; - current-midi depends on cursor position and
433     ("Midi" . (,(concat LilyPond-midi-command " " (LilyPond-string-current-midi)))) ; 
434     ;; - all-midi depends on number of midi-score.
435     ("MidiAll" . (,(concat LilyPond-all-midi-command " " (LilyPond-string-all-midi))))
436     )
437
438   "AList of commands to execute on the current document.
439
440 The key is the name of the command as it will be presented to the
441 user, the value is a cons of the command string handed to the shell
442 after being expanded, and the next command to be executed upon
443 success.  The expansion is done using the information found in
444 LilyPond-expand-list.
445 "
446   :group 'LilyPond
447   :type '(repeat (cons :tag "Command Item"
448                        (string :tag "Key")
449                        (cons :tag "How"
450                         (string :tag "Command")
451                         (string :tag "Next Key")))))
452
453 ;; drop this?
454 (defcustom LilyPond-file-extension ".ly"
455   "*File extension used in LilyPond sources."
456   :group 'LilyPond
457   :type 'string)
458
459
460 (defcustom LilyPond-expand-alist 
461   '(
462     ("%s" . ".ly")
463     ("%t" . ".tex")
464     ("%d" . ".dvi")
465     ("%p" . ".ps")
466     ("%l" . ".tex")
467     ("%x" . ".tely")
468     ("%m" . ".midi")
469     )
470     
471   "Alist of expansion strings for LilyPond command names."
472   :group 'LilyPond
473   :type '(repeat (cons :tag "Alist item"
474                   (string :tag "Symbol")
475                   (string :tag "Expansion")))) 
476
477
478 (defcustom LilyPond-command-Show "View"
479   "*The default command to show (view or print) a LilyPond file.
480 Must be the car of an entry in `LilyPond-command-alist'."
481   :group 'LilyPond
482   :type 'string)
483   (make-variable-buffer-local 'LilyPond-command-Show)
484
485 (defcustom LilyPond-command-Print "Print"
486   "The name of the Print entry in LilyPond-command-Print."
487   :group 'LilyPond
488   :type 'string)
489
490 (defun LilyPond-find-required-command (command file)
491   "Find the first command in the chain that is needed to run
492  (input file is newer than the output file)"
493   (let* ((entry (cdr (assoc command LilyPond-command-alist)))
494         (next-command (nth 3 entry)))
495     (if (null next-command)
496         command
497       (let* ((src-string (nth 1 entry))
498             (input (LilyPond-command-expand src-string file))
499             (output (LilyPond-command-expand (nth 2 entry) file)))
500         (if (or (file-newer-than-file-p input output)
501                 (and (equal "%s" src-string)
502                      (not (equal (buffer-name) file))
503                      (file-newer-than-file-p (buffer-name)
504                                              output)))
505             command
506           (LilyPond-find-required-command next-command file))))))
507
508 (defun LilyPond-command-query (name)
509   "Query the user for what LilyPond command to use."
510   (cond ((string-equal name LilyPond-region-file-prefix)
511          (LilyPond-check-files (concat name ".tex")
512                                (list name)
513                                (list LilyPond-file-extension)))
514         ((verify-visited-file-modtime (current-buffer))
515          (and (buffer-modified-p)
516               (y-or-n-p "Save buffer before next command? ")
517               (LilyPond-save-buffer)))
518         ((y-or-n-p "The command will be invoked to an already saved buffer. Revert it? ")
519          (revert-buffer t t)))
520     
521   (let* ((default (LilyPond-find-required-command LilyPond-command-next name))
522          (completion-ignore-case t)
523          (answer (or LilyPond-command-force
524                      (completing-read
525                       (concat "Command: (default " default ") ")
526                       LilyPond-command-alist nil t nil 'LilyPond-command-history))))
527
528     ;; If the answer is "LilyPond" it will not be expanded to "LilyPond"
529     (let ((answer (car-safe (assoc answer LilyPond-command-alist))))
530       (if (and answer
531                (not (string-equal answer "")))
532           answer
533         default))))
534
535 (defun LilyPond-command-master ()
536   "Run command on the current document."
537   (interactive)
538   (LilyPond-command-select-master)
539   (LilyPond-command (LilyPond-command-query (LilyPond-get-master-file))
540                     'LilyPond-get-master-file))
541
542 (defun LilyPond-command-lilypond ()
543   "Run lilypond for the current document."
544   (interactive)
545   (LilyPond-command (LilyPond-command-menu "LilyPond") 'LilyPond-get-master-file)
546 )
547
548 (defun LilyPond-command-formatdvi ()
549   "Format the dvi output of the current document."
550   (interactive)
551   (LilyPond-command (LilyPond-command-menu "2Dvi") 'LilyPond-get-master-file)
552 )
553
554 (defun LilyPond-command-formatps ()
555   "Format the ps output of the current document."
556   (interactive)
557   (LilyPond-command (LilyPond-command-menu "2PS") 'LilyPond-get-master-file)
558 )
559
560 (defun LilyPond-command-formatmidi ()
561   "Format the midi output of the current document."
562   (interactive)
563   (LilyPond-command (LilyPond-command-menu "2Midi") 'LilyPond-get-master-file)
564 )
565
566 (defun LilyPond-command-smartview ()
567   "View the dvi output of current document."
568   (interactive)
569   (LilyPond-command (LilyPond-command-menu "SmartView") 'LilyPond-get-master-file)
570 )
571
572 (defun LilyPond-command-view ()
573   "View the dvi output of current document."
574   (interactive)
575   (LilyPond-command (LilyPond-command-menu "View") 'LilyPond-get-master-file)
576 )
577
578 (defun LilyPond-command-viewps ()
579   "View the ps output of current document."
580   (interactive)
581   (LilyPond-command (LilyPond-command-menu "ViewPS") 'LilyPond-get-master-file)
582 )
583
584 ;; FIXME, this is broken
585 (defun LilyPond-region-file (begin end)
586   (let (
587         ;; (dir "./")
588         (dir (LilyPond-temp-directory))
589         (base LilyPond-region-file-prefix)
590         (ext LilyPond-file-extension))
591     (concat dir base ext)))
592
593 ;;; Commands on Region work if there is an appropriate '\score'.
594 (defun LilyPond-command-region (begin end)
595   "Run LilyPond on the current region."
596   (interactive "r")
597   (if (or (> begin (point-min)) (< end (point-max)))
598       (LilyPond-command-select-region))
599   (write-region begin end (LilyPond-region-file begin end) nil 'nomsg)
600   (LilyPond-command (LilyPond-command-query
601                      (LilyPond-region-file begin end))
602                     '(lambda () (LilyPond-region-file begin end)))
603   ;; Region may deactivate even if buffer was intact, reactivate?
604   ;; Currently, also deactived regions are used.
605   )
606
607 (defun LilyPond-command-buffer ()
608   "Run LilyPond on buffer."
609   (interactive)
610   (LilyPond-command-select-buffer)
611   (LilyPond-command-region (point-min) (point-max)))
612
613 (defun LilyPond-command-expand (string file)
614   (let ((case-fold-search nil))
615     (if (string-match "%" string)
616         (let* ((b (match-beginning 0))
617                (e (+ b 2))
618                (l (split-file-name file))
619                (dir (car l))
620                (base (cadr l)))
621           (LilyPond-command-expand
622            (concat (substring string 0 b)
623                    dir
624                    base
625                    (let ((entry (assoc (substring string b e)
626                                        LilyPond-expand-alist)))
627                      (if entry (cdr entry) ""))
628                    (substring string e))
629            file))
630       string)))
631
632 (defun LilyPond-shell-process (name buffer command)
633   (let ((old (current-buffer)))
634     (switch-to-buffer-other-window buffer)
635     ;; If we empty the buffer don't see messages scroll by.
636     ;; (erase-buffer)
637     
638     (start-process-shell-command name buffer command)
639     (switch-to-buffer-other-window old)))
640   
641
642 (defun LilyPond-command (name file)
643   "Run command NAME on the file you get by calling FILE.
644
645 FILE is a function return a file name.  It has one optional argument,
646 the extension to use on the file.
647
648 Use the information in LilyPond-command-alist to determine how to run the
649 command."
650
651   (let ((entry (assoc name LilyPond-command-alist)))
652     (if entry
653         (let ((command (LilyPond-command-expand (cadr entry)
654                                                 (apply file nil)))
655               (jobs nil)
656               (job-string "no jobs"))
657           (if (member name (list "View" "ViewPS"))
658               ;; is USR1 a right signal for viewps?
659               (let ((buffer-xdvi (get-buffer-create (concat "*" name "*"))))
660                 ;; what if XEDITOR is set to gedit or so, should we steal it?
661                 (if (not (getenv "XEDITOR"))
662                     (setenv "XEDITOR" "emacsclient --no-wait +%l:%c %f"))
663                 (if LilyPond-kick-xdvi
664                   (let ((process-xdvi (get-buffer-process buffer-xdvi)))
665                     (if process-xdvi
666                         (signal-process (process-id process-xdvi) 'SIGUSR1)
667                       (LilyPond-shell-process name buffer-xdvi command)))
668                   (LilyPond-shell-process name buffer-xdvi command)))
669             (progn
670               (if (string-equal name "Midi")
671                   (progn
672                     (setq command (concat LilyPond-midi-command " " (LilyPond-string-current-midi)))
673                     (if (LilyPond-kill-midi)
674                         (setq job-string nil)))) ; either stop or start playing
675               (if (string-equal name "MidiAll")
676                   (progn
677                     (setq command (concat LilyPond-all-midi-command " " (LilyPond-string-all-midi)))
678                     (LilyPond-kill-midi))) ; stop and start playing
679               (if (and (member name (list "Midi" "MidiAll")) job-string)
680                   (if (file-newer-than-file-p
681                        (LilyPond-get-master-file)
682                        (concat (substring (LilyPond-get-master-file) 0 -3) ".midi"))
683                       (if (y-or-n-p "Midi older than source. Reformat midi?")
684                           (progn
685                             (LilyPond-command-formatmidi)
686                             (while (LilyPond-running)
687                               (message "Starts playing midi once it is built.")
688                               (sit-for 0 100))))))
689               (if (member name (list "LilyPond" "TeX" "2Midi" "2PS" "2Dvi" 
690                                      "Book" "LaTeX"))
691                   (if (setq jobs (LilyPond-running))
692                       (progn
693                         (setq job-string "Process") ; could also suggest compiling after process has ended
694                         (while jobs
695                           (setq job-string (concat job-string " \"" (pop jobs) "\"")))
696                         (setq job-string (concat job-string " is already running; kill it to proceed "))
697                         (if (y-or-n-p job-string)
698                             (progn
699                               (setq job-string "no jobs")
700                               (LilyPond-kill-jobs)
701                               (while (LilyPond-running)
702                                 (sit-for 0 100)))
703                           (setq job-string nil)))))
704
705               (setq LilyPond-command-next
706                     (let* ((entry (assoc name LilyPond-command-alist))
707                            (next-command (nth 3 (cdr entry))))
708                       (or next-command
709                           LilyPond-command-default)))
710               
711               (if (string-equal job-string "no jobs")
712                   (LilyPond-compile-file command name))))))))
713           
714 (defun LilyPond-mark-active ()
715   "Check if there is an active mark."
716   (and transient-mark-mode
717        (if (string-match "XEmacs\\|Lucid" emacs-version) (mark) mark-active)))
718
719 (defun LilyPond-temp-directory ()
720   "Temporary file directory for Commands on Region."
721   (interactive)
722   (if (string-match "XEmacs\\|Lucid" emacs-version)
723       (concat (temp-directory) "/")
724     temporary-file-directory))
725
726 ;;; Keymap
727
728 (defvar LilyPond-mode-map ()
729   "Keymap used in `LilyPond-mode' buffers.")
730
731 ;; Note:  if you make changes to the map, you must do
732 ;;    M-x set-variable LilyPond-mode-map nil
733 ;;    M-x eval-buffer
734 ;;    M-x LilyPond-mode
735 ;; to let the changest take effect
736
737 (if LilyPond-mode-map
738     ()
739   (setq LilyPond-mode-map (make-sparse-keymap))
740   ;; Put keys to LilyPond-command-alist and fetch them from there somehow.
741   (define-key LilyPond-mode-map "\C-c\C-l" 'LilyPond-command-lilypond)
742   (define-key LilyPond-mode-map "\C-c\C-r" 'LilyPond-command-region)
743   (define-key LilyPond-mode-map "\C-c\C-b" 'LilyPond-command-buffer)
744   (define-key LilyPond-mode-map "\C-c\C-k" 'LilyPond-kill-jobs)
745   (define-key LilyPond-mode-map "\C-c\C-c" 'LilyPond-command-master)
746   (define-key LilyPond-mode-map "\C-cm" 'LilyPond-command-formatmidi)
747   (define-key LilyPond-mode-map "\C-c\C-d" 'LilyPond-command-formatdvi)
748   (define-key LilyPond-mode-map "\C-c\C-f" 'LilyPond-command-formatps)
749   (define-key LilyPond-mode-map "\C-c\C-s" 'LilyPond-command-smartview)
750   (define-key LilyPond-mode-map "\C-c\C-v" 'LilyPond-command-view)
751   (define-key LilyPond-mode-map "\C-c\C-p" 'LilyPond-command-viewps)
752   (define-key LilyPond-mode-map [(control c) return] 'LilyPond-command-current-midi)
753   (define-key LilyPond-mode-map [(control c) (control return)] 'LilyPond-command-all-midi)
754   (define-key LilyPond-mode-map "\C-x\C-s" 'LilyPond-save-buffer)
755   (define-key LilyPond-mode-map "\C-cb" 'LilyPond-what-beat)
756   (define-key LilyPond-mode-map "\C-cf" 'font-lock-fontify-buffer)
757   (define-key LilyPond-mode-map "\C-ci" 'LilyPond-insert-tag-current)
758   ;; the following will should be overriden by Lilypond Quick Insert Mode
759   (define-key LilyPond-mode-map "\C-cq" 'LilyPond-quick-insert-mode)
760   (define-key LilyPond-mode-map "\C-c;" 'LilyPond-comment-region)
761   (define-key LilyPond-mode-map ")" 'LilyPond-electric-close-paren)
762   (define-key LilyPond-mode-map ">" 'LilyPond-electric-close-paren)
763   (define-key LilyPond-mode-map "}" 'LilyPond-electric-close-paren)
764   (define-key LilyPond-mode-map "]" 'LilyPond-electric-close-paren)
765   (define-key LilyPond-mode-map "|" 'LilyPond-electric-bar)
766   (if (string-match "XEmacs\\|Lucid" emacs-version)
767       (define-key LilyPond-mode-map [iso-left-tab] 'LilyPond-autocompletion)
768     (define-key LilyPond-mode-map [iso-lefttab] 'LilyPond-autocompletion))
769   (define-key LilyPond-mode-map "\C-c\t" 'LilyPond-info-index-search)
770   )
771
772 ;;; Menu Support
773
774 ;;; This mode was originally LilyPond-quick-note-insert by Heikki Junes.
775 ;;; The original version has been junked since CVS-1.97,
776 ;;; in order to merge the efforts done by Nicolas Sceaux.
777 ;;; LilyPond Quick Insert Mode is a major mode, toggled by C-c q.
778 (defun LilyPond-quick-insert-mode ()
779   "Insert notes with fewer key strokes by using a simple keyboard piano."
780   (interactive)
781   (progn 
782     (message "Invoke (C-c q) from keyboard. If you still see this message,") (sit-for 5 0)
783     (message "then you have not installed LilyPond Quick Insert Mode (lyqi).") (sit-for 5 0)
784     (message "Download lyqi from http://nicolas.sceaux.free.fr/lilypond/lyqi.html,") (sit-for 5 0)
785     (message "see installation instructions from lyqi's README -file.") (sit-for 5 0)
786     (message "You need also eieio (Enhanced Integration of Emacs Interpreted Objects).") (sit-for 5 0)
787     (message "Download eieio from http://cedet.sourceforge.net/eieio.shtml,") (sit-for 5 0)
788     (message "see installation instructions from eieio's INSTALL -file.") (sit-for 5 0)
789     (message "")
790     ))    
791
792 (defun LilyPond-pre-word-search ()
793   "Fetch the alphabetic characters and \\ in front of the cursor."
794   (let ((pre "")
795         (prelen 0)
796         (ch (char-before (- (point) 0))))
797     (while (and ch (or (and (>= ch 65) (<= ch 90))  ; not bolp, A-Z
798                        (and (>= ch 97) (<= ch 122)) ; a-z
799                        (= ch 92)))                  ; \\
800       (setq pre (concat (char-to-string ch) pre))
801       (setq prelen (+ prelen 1))
802       (setq ch (char-before (- (point) prelen))))
803     pre))
804
805 (defun LilyPond-post-word-search ()
806   "Fetch the alphabetic characters behind the cursor."
807   (let ((post "")
808         (postlen 0)
809         (ch (char-after (+ (point) 0))))
810     (while (and ch (or (and (>= ch 65) (<= ch 90))    ; not eolp, A-Z
811                        (and (>= ch 97) (<= ch 122)))) ; a-z
812       (setq post (concat post (char-to-string ch)))
813       (setq postlen (+ postlen 1))
814       (setq ch (char-after (+ (point) postlen))))
815     post))
816
817 (defun LilyPond-autocompletion ()
818   "Show completions in mini-buffer for the given word."
819   (interactive)
820   (let ((pre (LilyPond-pre-word-search))
821         (post (LilyPond-post-word-search))
822         (compsstr ""))
823     ;; insert try-completion and show all-completions
824     (if (> (length pre) 0)
825         (progn
826           (setq trycomp (try-completion pre (LilyPond-add-dictionary-word ())))
827           (if (char-or-string-p trycomp)
828               (if (string-equal (concat pre post) trycomp)
829                   (goto-char (+ (point) (length post)))
830                 (progn
831                   (delete-region (point) (+ (point) (length post)))
832                   (insert (substring trycomp (length pre) nil))))
833             (progn
834               (delete-region (point) (+ (point) (length post)))
835               (font-lock-fontify-buffer))) ; only inserting fontifies
836         
837         (setq complist (all-completions pre (LilyPond-add-dictionary-word ())))
838         (while (> (length complist) 0)
839           (setq compsstr (concat compsstr "\"" (car complist) "\" "))
840           (setq complist (cdr complist)))
841         (message compsstr) 
842         (sit-for 0 100)))))
843
844 (defun LilyPond-info ()
845   "Launch Info for lilypond."
846   (interactive)
847   (info "lilypond"))
848   
849 (defun LilyPond-music-glossary-info ()
850   "Launch Info for music-glossary."
851   (interactive)
852   (info "music-glossary"))
853
854 (defun LilyPond-internals-info ()
855   "Launch Info for lilypond-internals."
856   (interactive)
857   (info "lilypond-internals"))
858   
859 (defun LilyPond-info-index-search ()
860   "In `*info*'-buffer, launch `info lilypond --index-search word-under-cursor'"
861   (interactive)
862   (let ((str (concat (LilyPond-pre-word-search) (LilyPond-post-word-search))))
863     (if (and (> (length str) 0) 
864              (string-equal (substring str 0 1) "\\"))
865         (setq str (substring str 1 nil)))
866     (LilyPond-info)
867     (Info-index str)))
868
869 (defun LilyPond-insert-tag-current (&optional word)
870   "Set the current tag to be inserted."
871   (interactive)
872   (if word
873       (setq LilyPond-insert-tag-current word))
874   (if (memq LilyPond-insert-tag-current LilyPond-menu-keywords)
875       (LilyPond-insert-tag)
876     (message "No tag was selected from LilyPond->Insert tag-menu.")))
877
878 (defun LilyPond-insert-tag ()
879   "Insert syntax for given tag. The definitions are in LilyPond-words-filename."
880   (interactive)
881   (setq b (find-file-noselect (LilyPond-words-filename) t t))
882   (let ((word LilyPond-insert-tag-current)
883         (found nil)
884         (p nil)
885         (query nil)
886         (m (set-marker (make-marker) 1 (get-buffer b)))
887         (distance (if (LilyPond-mark-active)
888                       (abs (- (mark-marker) (point-marker))) 0))
889        )
890    ;; find the place first
891    (if (LilyPond-mark-active)
892        (goto-char (min (mark-marker) (point-marker))))
893    (while (and (not found) (> (get-buffer-size b) (marker-position m)))
894     (setq copy (car (copy-alist (list (eval (symbol-name (read m)))))))
895     (if (string-equal word copy) (setq found t)))
896    (if found (insert word))
897    (if (> (get-buffer-size b) (marker-position m))
898        (setq copy (car (copy-alist (list (eval (symbol-name (read m))))))))
899    (if (not (string-equal "-" copy)) 
900        (setq found nil))
901    (while (and found (> (get-buffer-size b) (marker-position m)))
902     ;; find next symbol
903     (setq copy (car (copy-alist (list (eval (symbol-name (read m)))))))
904     ;; check whether it is the word, or the word has been found
905     (cond 
906      ((string-equal "-" copy) (setq found nil))
907      ((string-equal "%" copy) (insert " " (read-string "Give Arguments: ")))
908      ((string-equal "_" copy) 
909       (progn 
910        (setq p (point))
911        (goto-char (+ p distance))))
912      ((string-equal "\?" copy) (setq query t))
913      ((string-equal "\!" copy) (setq query nil))
914      ((string-equal "\\n" copy) 
915       (if (not query)
916        (progn (LilyPond-indent-line) (insert "\n") (LilyPond-indent-line))))
917      ((string-equal "{" copy) 
918       (if (not query) 
919           (progn (insert " { "))))
920      ((string-equal "}" copy)
921       (if (not query)
922        (progn (insert " } ") (setq query nil) )))
923      ((not query)
924       (insert copy))
925      (query
926       (if (y-or-n-p (concat "Proceed with `" copy "'? "))
927        (progn (insert copy) (setq query nil))))
928    ))
929    (if p (goto-char p))
930    (kill-buffer b))
931 )
932
933 (defun LilyPond-command-menu-entry (entry)
934   ;; Return LilyPond-command-alist ENTRY as a menu item.
935   (let ((name (car entry)))
936     (cond ((and (string-equal name LilyPond-command-Print)
937                 LilyPond-printer-list)
938            (let ((command LilyPond-print-command)
939                  (lookup 1))
940              (append (list LilyPond-command-Print)
941                      (mapcar 'LilyPond-command-menu-printer-entry
942                              LilyPond-printer-list))))
943           (t
944            (vector name (list 'LilyPond-command-menu name) t)))))
945
946
947 (easy-menu-define LilyPond-command-menu
948   LilyPond-mode-map
949   "Menu used in LilyPond mode."
950   (append '("Command")
951           '(("Command on"
952              [ "Master File" LilyPond-command-select-master
953                :keys "C-c C-c" :style radio
954                :selected (eq LilyPond-command-current 'LilyPond-command-master) ]
955              [ "Buffer" LilyPond-command-select-buffer
956                :keys "C-c C-b" :style radio
957                :selected (eq LilyPond-command-current 'LilyPond-command-buffer) ]
958              [ "Region" LilyPond-command-select-region
959                :keys "C-c C-r" :style radio
960                :selected (eq LilyPond-command-current 'LilyPond-command-region) ]))
961 ;;;       (let ((file 'LilyPond-command-on-current))
962 ;;;         (mapcar 'LilyPond-command-menu-entry LilyPond-command-alist))
963 ;;; Some kind of mapping which includes :keys might be more elegant
964 ;;; Put keys to LilyPond-command-alist and fetch them from there somehow.
965           '([ "LilyPond" LilyPond-command-lilypond t])
966           '([ "TeX" (LilyPond-command (LilyPond-command-menu "TeX") 'LilyPond-get-master-file) ])
967           '([ "2Dvi" LilyPond-command-formatdvi t])
968           '([ "2PS" LilyPond-command-formatps t])
969           '([ "2Midi" LilyPond-command-formatmidi t])
970           '([ "Book" (LilyPond-command (LilyPond-command-menu "Book") 'LilyPond-get-master-file) ])
971           '([ "LaTeX" (LilyPond-command (LilyPond-command-menu "LaTeX") 'LilyPond-get-master-file) ])
972           '([ "Kill jobs" LilyPond-kill-jobs t])
973           '("-----")
974           '([ "SmartView" LilyPond-command-smartview t])
975           '([ "View" LilyPond-command-view t])
976           '([ "ViewPS" LilyPond-command-viewps t])
977           '("-----")
978           '([ "Midi (toggle)" LilyPond-command-current-midi t])
979           '([ "Midi all" LilyPond-command-all-midi t])
980           ))
981
982 (defun LilyPond-menu-keywords-item (arg)
983   "Make vector for LilyPond-mode-keywords."
984   (vector arg (list 'LilyPond-insert-tag-current arg) :style 'radio :selected (list 'eq 'LilyPond-insert-tag-current arg)))
985
986 (defun LilyPond-menu-keywords ()
987   "Make Insert Tag menu. 
988
989 The Insert Tag -menu is splitted into parts if it is long enough."
990
991   (let ((li (mapcar 'LilyPond-menu-keywords-item LilyPond-menu-keywords))
992         (w (round (sqrt (length LilyPond-menu-keywords))))
993         (splitted '())
994         (imin 0) imax lw rw)
995     (while (< imin (length LilyPond-menu-keywords))
996       (setq imax (- (min (+ imin w) (length LilyPond-menu-keywords)) 1))
997       (setq lw (nth imin LilyPond-menu-keywords)) 
998       (setq rw (nth imax LilyPond-menu-keywords))
999       (add-to-list 'splitted
1000          (let ((l (list (concat (substring lw 0 (min 7 (length lw))) 
1001                                 " ... " 
1002                                 (substring rw 0 (min 7 (length rw)))))))
1003            (while (<= imin imax)
1004              (add-to-list 'l (nth imin li))
1005              (setq imin (1+ imin)))
1006            (reverse l))))
1007     (if (> (length LilyPond-menu-keywords) 12) (reverse splitted) li)))
1008
1009 ;;; LilyPond-mode-menu should not be interactive, via "M-x LilyPond-<Tab>"
1010 (easy-menu-define LilyPond-mode-menu
1011   LilyPond-mode-map
1012   "Menu used in LilyPond mode."
1013   (append '("LilyPond")
1014           '(["Add index menu" LilyPond-add-imenu-menu])
1015           (list (cons "Insert tag" 
1016                 (cons ["Previously selected" LilyPond-insert-tag-current t] 
1017                 (cons "-----"
1018                       (LilyPond-menu-keywords)))))
1019           '(("Miscellaneous"
1020              ["Autocompletion"   LilyPond-autocompletion t]
1021              ["(Un)comment Region" LilyPond-comment-region t]
1022              ["Refontify buffer" font-lock-fontify-buffer t]
1023              "-----"
1024              ["Quick Insert Mode"  LilyPond-quick-insert-mode :keys "C-c q"]
1025              ))
1026           '(("Info"
1027              ["LilyPond" LilyPond-info t]
1028              ["LilyPond index-search" LilyPond-info-index-search t]
1029              ["Music Glossary" LilyPond-music-glossary-info t]
1030              ["LilyPond internals" LilyPond-internals-info t]
1031              ))
1032           ))
1033
1034 (defconst LilyPond-imenu-generic-re "^\\([a-zA-Z]+\\) *="
1035   "Regexp matching Identifier definitions.")
1036
1037 (defvar LilyPond-imenu-generic-expression
1038   (list (list nil LilyPond-imenu-generic-re 1))
1039   "Expression for imenu")
1040
1041 (defun LilyPond-command-select-master ()
1042   (interactive)
1043   (message "Next command will be on the master file")
1044   (setq LilyPond-command-current 'LilyPond-command-master))
1045
1046 (defun LilyPond-command-select-buffer ()
1047   (interactive)
1048   (message "Next command will be on the buffer")
1049   (setq LilyPond-command-current 'LilyPond-command-buffer))
1050
1051 (defun LilyPond-command-select-region ()
1052   (interactive)
1053   (message "Next command will be on the region")
1054   (setq LilyPond-command-current 'LilyPond-command-region))
1055
1056 (defun LilyPond-command-menu (name)
1057   ;; Execute LilyPond-command-alist NAME from a menu.
1058   (let ((LilyPond-command-force name))
1059     (if (eq LilyPond-command-current 'LilyPond-command-region)
1060         (if (eq (mark t) nil)
1061             (progn (message "The mark is not set now") (sit-for 0 500))
1062           (progn (if (not (not (LilyPond-mark-active)))
1063                      (progn (message "Region is not active, using region between inactive mark and current point.") (sit-for 0 500)))
1064                  (LilyPond-command-region (mark t) (point))))
1065       (funcall LilyPond-command-current))))
1066
1067 (defun LilyPond-add-imenu-menu ()
1068   (interactive)
1069   "Add an imenu menu to the menubar."
1070   (if (not LilyPond-imenu)
1071       (progn
1072         (imenu-add-to-menubar "Index")
1073         (redraw-frame (selected-frame))
1074         (setq LilyPond-imenu t))
1075     (message "%s" "LilyPond-imenu already exists.")))
1076 (put 'LilyPond-add-imenu-menu 'menu-enable '(not LilyPond-imenu))
1077
1078 (defun LilyPond-mode ()
1079   "Major mode for editing LilyPond music files.
1080
1081 This mode knows about LilyPond keywords and line comments, not about
1082 indentation or block comments.  It features easy compilation, error
1083 finding and viewing of a LilyPond source buffer or region.
1084
1085 COMMANDS
1086 \\{LilyPond-mode-map}
1087 VARIABLES
1088
1089 LilyPond-command-alist\t\talist from name to command
1090 LilyPond-xdvi-command\t\tcommand to display dvi files -- bit superfluous"
1091   (interactive)
1092   ;; set up local variables
1093   (kill-all-local-variables)
1094
1095   (make-local-variable 'font-lock-defaults)
1096   (setq font-lock-defaults '(LilyPond-font-lock-keywords))
1097
1098   ;; string and comments are fontified explicitly
1099   (make-local-variable 'font-lock-keywords-only)
1100   (setq font-lock-keywords-only t)
1101
1102   ;; Multi-line font-locking needs Emacs 21.1 or newer.
1103   ;; For older versions there is hotkey "C-c f".
1104   (make-local-variable 'font-lock-multiline) 
1105   (setq font-lock-multiline t) 
1106
1107   (make-local-variable 'paragraph-separate)
1108   (setq paragraph-separate "^[ \t]*$")
1109
1110   (make-local-variable 'paragraph-start)
1111   (setq paragraph-start "^[ \t]*$")
1112
1113   (make-local-variable 'comment-start)
1114   (setq comment-start "%")
1115
1116   (make-local-variable 'comment-start-skip)
1117   (setq comment-start-skip "%{? *")
1118
1119   (make-local-variable 'comment-end)
1120   (setq comment-end "")
1121
1122   (make-local-variable 'block-comment-start)
1123   (setq block-comment-start "%{")
1124
1125   (make-local-variable 'block-comment-end)  
1126   (setq block-comment-end   "%}")
1127
1128   (make-local-variable 'indent-line-function)
1129   (setq indent-line-function 'LilyPond-indent-line)
1130
1131   (LilyPond-mode-set-syntax-table '(?\< ?\> ?\{ ?\}))
1132   (setq major-mode 'LilyPond-mode)
1133   (setq mode-name "LilyPond")
1134   (setq local-abbrev-table LilyPond-mode-abbrev-table)
1135   (use-local-map LilyPond-mode-map)
1136
1137   ;; In XEmacs imenu was synched up with: FSF 20.4
1138   (make-local-variable 'imenu-generic-expression)
1139   (setq imenu-generic-expression LilyPond-imenu-generic-expression)
1140   ;; (imenu-add-to-menubar "Index") ; see LilyPond-add-imenu-menu
1141
1142   ;; In XEmacs one needs to use 'easy-menu-add'.
1143   (if (string-match "XEmacs\\|Lucid" emacs-version)
1144       (progn
1145         (easy-menu-add LilyPond-mode-menu)
1146         (easy-menu-add LilyPond-command-menu)))
1147
1148   ;; Use Command on Region even for inactive mark (region).
1149   (if (string-match "XEmacs\\|Lucid" emacs-version)
1150       (setq zmacs-regions nil)
1151     (setq mark-even-if-inactive t))
1152
1153   ;; Context dependent syntax tables in LilyPond-mode
1154   (make-local-hook 'post-command-hook) ; XEmacs requires
1155   (add-hook 'post-command-hook 'LilyPond-mode-context-set-syntax-table nil t)
1156
1157   ;; Turn on paren-mode buffer-locally, i.e., in LilyPond-mode
1158   (if (string-match "XEmacs\\|Lucid" emacs-version)
1159       (progn
1160         (make-local-variable 'paren-mode)
1161         (paren-set-mode 'paren)
1162         (make-local-variable 'blink-matching-paren)
1163         (setq blink-matching-paren t)
1164         )
1165     (progn
1166       (make-local-variable 'blink-matching-paren-on-screen)
1167       (setq blink-matching-paren-on-screen t)
1168      ))
1169
1170   ;; run the mode hook. LilyPond-mode-hook use is deprecated
1171   (run-hooks 'LilyPond-mode-hook))
1172
1173 (defun LilyPond-version ()
1174   "Echo the current version of `LilyPond-mode' in the minibuffer."
1175   (interactive)
1176   (message "Using `LilyPond-mode' version %s" LilyPond-version))
1177
1178 (load-library "lilypond-font-lock")
1179 (load-library "lilypond-indent")
1180 (load-library "lilypond-what-beat")
1181
1182 (defun LilyPond-guile ()
1183   (interactive)
1184   (require 'ilisp)
1185   (guile "lilyguile" (LilyPond-command-expand (cadr (assoc "2Dvi" LilyPond-command-alist))
1186                                               (funcall 'LilyPond-get-master-file)))
1187   (comint-default-send (ilisp-process) "(define-module (*anonymous-ly-0*))")
1188   (comint-default-send (ilisp-process) "(set! %load-path (cons \"/usr/share/ilisp/\" %load-path))")
1189   (comint-default-send (ilisp-process) "(use-modules (guile-user) (guile-ilisp))")
1190   (comint-default-send (ilisp-process) "(newline)"))
1191
1192 (provide 'lilypond-mode)
1193 ;;; lilypond-mode.el ends here
1194