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-lilypond-command "lilypond"
 326   "Command used to compile LY files."
 327   :group 'LilyPond
 328   :type 'string)
 329
 330 (defcustom LilyPond-xdvi-command "xdvi"
 331   "Command used to display DVI files."
 332
 333   :group 'LilyPond
 334   :type 'string)
 335
 336 (defcustom LilyPond-gv-command "gv --watch"
 337   "Command used to display PS files."
 338
 339   :group 'LilyPond
 340   :type 'string)
 341
 342 (defcustom LilyPond-midi-command "timidity"
 343   "Command used to play MIDI files."
 344
 345   :group 'LilyPond
 346   :type 'string)
 347
 348 (defcustom LilyPond-all-midi-command "timidity -ia"
 349   "Command used to play MIDI files."
 350
 351   :group 'LilyPond
 352   :type 'string)
 353
 354 (defun LilyPond-command-current-midi ()
 355   "Play midi corresponding to the current document."
 356   (interactive)
 357   (LilyPond-command (LilyPond-command-menu "Midi") 'LilyPond-get-master-file))
 358
 359 (defun LilyPond-command-all-midi ()
 360   "Play midi corresponding to the current document."
 361   (interactive)
 362   (LilyPond-command (LilyPond-command-menu "MidiAll") 'LilyPond-get-master-file))
 363
 364 (defun count-rexp (start end rexp)
 365   "Print number of found regular expressions in the region."
 366   (interactive "r")
 367   (save-excursion
 368     (save-restriction
 369       (narrow-to-region start end)
 370       (goto-char (point-min))
 371       (count-matches rexp))))
 372
 373 (defun count-midi-words ()
 374   "Check number of midi-scores before the curser."
 375   (if (eq LilyPond-command-current 'LilyPond-command-region)
 376       (count-rexp (mark t) (point) "\\\\midi")
 377     (count-rexp (point-min) (point-max) "\\\\midi")))
 378
 379 (defun count-midi-words-backwards ()
 380   "Check number of midi-scores before the curser."
 381   (if (eq LilyPond-command-current 'LilyPond-command-region)
 382       (count-rexp (mark t) (point) "\\\\midi")
 383     (count-rexp (point-min) (point) "\\\\midi")))
 384
 385 (defun LilyPond-string-current-midi ()
 386   "Check the midi file of the following midi-score in the current document."
 387   (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master)
 388                          (substring (LilyPond-get-master-file) 0 -3); suppose ".ly"
 389                        LilyPond-region-file-prefix))
 390         (allcount (string-to-number (substring (count-midi-words) 0 -12)))
 391         (count (string-to-number (substring (count-midi-words-backwards) 0 -12))))
 392     (concat  fnameprefix
 393              (if (and (> allcount 1) (> count 0)) ; not first score
 394                  (if (eq count allcount)          ; last score
 395                      (concat "-" (number-to-string (+ count -1)))
 396                    (concat "-" (number-to-string count))))
 397              ".midi")))
 398
 399 (defun LilyPond-string-all-midi ()
 400   "Return the midi files of the current document in ascending order."
 401   (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master)
 402                          (substring (LilyPond-get-master-file) 0 -3); suppose ".ly"
 403                        LilyPond-region-file-prefix))
 404         (allcount (string-to-number (substring (count-midi-words) 0 -12))))
 405     (concat (if (> allcount 0)  ; at least one midi-score
 406                 (concat fnameprefix ".midi "))
 407             (if (> allcount 1)  ; more than one midi-score
 408                 (concat fnameprefix "-[1-9].midi "))
 409             (if (> allcount 9)  ; etc.
 410                 (concat fnameprefix "-[1-9][0-9].midi"))
 411             (if (> allcount 99) ; not first score
 412                 (concat fnameprefix "-[1-9][0-9][0-9].midi")))))
 413
 414 ;; This is the major configuration variable.
 415 (defcustom LilyPond-command-alist
 416   ;; Should expand this to include possible keyboard shortcuts which
 417   ;; could then be mapped to define-key and menu.
 418   `(
 419     ("LilyPond" . (,(concat LilyPond-lilypond-command " -ftex %s") "%s" "%l" "View"))
 420     ("TeX" . ("tex '\\nonstopmode\\input %t'" "%t" "%d" "View"))
 421
 422     ("2Dvi" . (,(concat LilyPond-lilypond-command " -f tex %s") "%s" "%d" "LaTeX"))
 423     ("2PS" . (,(concat LilyPond-lilypond-command " -f ps %s") "%s" "%p" "ViewPS"))
 424     ("2Midi" . (,(concat LilyPond-lilypond-command " -m %s") "%s" "%m" "Midi"))
 425     ("2Gnome" . (,(concat LilyPond-lilypond-command " -b gnome %s")))
 426
 427     ("Book" . ("lilypond-book %x" "%x" "%l" "LaTeX"))
 428     ("LaTeX" . ("latex '\\nonstopmode\\input %l'" "%l" "%d" "View"))
 429
 430     ;; point-n-click (arg: exits upop USR1)
 431     ("SmartView" . ("xdvi %d"))
 432
 433     ;; refreshes when kicked USR1
 434     ("View" . (,(concat LilyPond-xdvi-command " %d")))
 435     ("ViewPS" . (,(concat LilyPond-gv-command " %p")))
 436
 437     ;; The following are refreshed in LilyPond-command:
 438     ;; - current-midi depends on cursor position and
 439     ("Midi" . (,(concat LilyPond-midi-command " " (LilyPond-string-current-midi)))) ;
 440     ;; - all-midi depends on number of midi-score.
 441     ("MidiAll" . (,(concat LilyPond-all-midi-command " " (LilyPond-string-all-midi))))
 442     )
 443
 444   "AList of commands to execute on the current document.
 445
 446 The key is the name of the command as it will be presented to the
 447 user, the value is a cons of the command string handed to the shell
 448 after being expanded, and the next command to be executed upon
 449 success.  The expansion is done using the information found in
 450 LilyPond-expand-list.
 451 "
 452   :group 'LilyPond
 453   :type '(repeat (cons :tag "Command Item"
 454                        (string :tag "Key")
 455                        (cons :tag "How"
 456                         (string :tag "Command")
 457                         (string :tag "Next Key")))))
 458
 459 ;; drop this?
 460 (defcustom LilyPond-file-extension ".ly"
 461   "*File extension used in LilyPond sources."
 462   :group 'LilyPond
 463   :type 'string)
 464
 465
 466 (defcustom LilyPond-expand-alist
 467   '(
 468     ("%s" . ".ly")
 469     ("%t" . ".tex")
 470     ("%d" . ".dvi")
 471     ("%p" . ".ps")
 472     ("%l" . ".tex")
 473     ("%x" . ".tely")
 474     ("%m" . ".midi")
 475     )
 476
 477   "Alist of expansion strings for LilyPond command names."
 478   :group 'LilyPond
 479   :type '(repeat (cons :tag "Alist item"
 480                   (string :tag "Symbol")
 481                   (string :tag "Expansion"))))
 482
 483
 484 (defcustom LilyPond-command-Show "View"
 485   "*The default command to show (view or print) a LilyPond file.
 486 Must be the car of an entry in `LilyPond-command-alist'."
 487   :group 'LilyPond
 488   :type 'string)
 489   (make-variable-buffer-local 'LilyPond-command-Show)
 490
 491 (defcustom LilyPond-command-Print "Print"
 492   "The name of the Print entry in LilyPond-command-Print."
 493   :group 'LilyPond
 494   :type 'string)
 495
 496 (defun LilyPond-find-required-command (command file)
 497   "Find the first command in the chain that is needed to run
 498  (input file is newer than the output file)"
 499   (let* ((entry (cdr (assoc command LilyPond-command-alist)))
 500         (next-command (nth 3 entry)))
 501     (if (null next-command)
 502         command
 503       (let* ((src-string (nth 1 entry))
 504             (input (LilyPond-command-expand src-string file))
 505             (output (LilyPond-command-expand (nth 2 entry) file)))
 506         (if (or (file-newer-than-file-p input output)
 507                 (and (equal "%s" src-string)
 508                      (not (equal (buffer-name) file))
 509                      (file-newer-than-file-p (buffer-name)
 510                                              output)))
 511             command
 512           (LilyPond-find-required-command next-command file))))))
 513
 514 (defun LilyPond-command-query (name)
 515   "Query the user for what LilyPond command to use."
 516   (cond ((string-equal name LilyPond-region-file-prefix)
 517          (LilyPond-check-files (concat name ".tex")
 518                                (list name)
 519                                (list LilyPond-file-extension)))
 520         ((verify-visited-file-modtime (current-buffer))
 521          (and (buffer-modified-p)
 522               (y-or-n-p "Save buffer before next command? ")
 523               (LilyPond-save-buffer)))
 524         ((y-or-n-p "The command will be invoked to an already saved buffer. Revert it? ")
 525          (revert-buffer t t)))
 526
 527   (let* ((default (LilyPond-find-required-command LilyPond-command-next name))
 528          (completion-ignore-case t)
 529          (answer (or LilyPond-command-force
 530                      (completing-read
 531                       (concat "Command: (default " default ") ")
 532                       LilyPond-command-alist nil t nil 'LilyPond-command-history))))
 533
 534     ;; If the answer is "LilyPond" it will not be expanded to "LilyPond"
 535     (let ((answer (car-safe (assoc answer LilyPond-command-alist))))
 536       (if (and answer
 537                (not (string-equal answer "")))
 538           answer
 539         default))))
 540
 541 (defun LilyPond-command-master ()
 542   "Run command on the current document."
 543   (interactive)
 544   (LilyPond-command-select-master)
 545   (LilyPond-command (LilyPond-command-query (LilyPond-get-master-file))
 546                     'LilyPond-get-master-file))
 547
 548 (defun LilyPond-command-lilypond ()
 549   "Run lilypond for the current document."
 550   (interactive)
 551   (LilyPond-command (LilyPond-command-menu "LilyPond") 'LilyPond-get-master-file)
 552 )
 553
 554 (defun LilyPond-command-formatdvi ()
 555   "Format the dvi output of the current document."
 556   (interactive)
 557   (LilyPond-command (LilyPond-command-menu "2Dvi") 'LilyPond-get-master-file)
 558 )
 559
 560 (defun LilyPond-command-formatps ()
 561   "Format the ps output of the current document."
 562   (interactive)
 563   (LilyPond-command (LilyPond-command-menu "2PS") 'LilyPond-get-master-file)
 564 )
 565
 566 (defun LilyPond-command-formatgnome ()
 567   "Format the gnome output of the current document."
 568   (interactive)
 569   (LilyPond-command (LilyPond-command-menu "2Gnome") 'LilyPond-get-master-file))
 570
 571 (defun LilyPond-command-formatmidi ()
 572   "Format the midi output of the current document."
 573   (interactive)
 574   (LilyPond-command (LilyPond-command-menu "2Midi") 'LilyPond-get-master-file)
 575 )
 576
 577 (defun LilyPond-command-smartview ()
 578   "View the dvi output of current document."
 579   (interactive)
 580   (LilyPond-command (LilyPond-command-menu "SmartView") 'LilyPond-get-master-file)
 581 )
 582
 583 (defun LilyPond-command-view ()
 584   "View the dvi output of current document."
 585   (interactive)
 586   (LilyPond-command (LilyPond-command-menu "View") 'LilyPond-get-master-file)
 587 )
 588
 589 (defun LilyPond-command-viewps ()
 590   "View the ps output of current document."
 591   (interactive)
 592   (LilyPond-command (LilyPond-command-menu "ViewPS") 'LilyPond-get-master-file)
 593 )
 594
 595 ;; FIXME, this is broken
 596 (defun LilyPond-region-file (begin end)
 597   (let (
 598         ;; (dir "./")
 599         (dir (LilyPond-temp-directory))
 600         (base LilyPond-region-file-prefix)
 601         (ext LilyPond-file-extension))
 602     (concat dir base ext)))
 603
 604 ;;; Commands on Region work if there is an appropriate '\score'.
 605 (defun LilyPond-command-region (begin end)
 606   "Run LilyPond on the current region."
 607   (interactive "r")
 608   (if (or (> begin (point-min)) (< end (point-max)))
 609       (LilyPond-command-select-region))
 610   (write-region begin end (LilyPond-region-file begin end) nil 'nomsg)
 611   (LilyPond-command (LilyPond-command-query
 612                      (LilyPond-region-file begin end))
 613                     '(lambda () (LilyPond-region-file begin end)))
 614   ;; Region may deactivate even if buffer was intact, reactivate?
 615   ;; Currently, also deactived regions are used.
 616   )
 617
 618 (defun LilyPond-command-buffer ()
 619   "Run LilyPond on buffer."
 620   (interactive)
 621   (LilyPond-command-select-buffer)
 622   (LilyPond-command-region (point-min) (point-max)))
 623
 624 (defun LilyPond-command-expand (string file)
 625   (let ((case-fold-search nil))
 626     (if (string-match "%" string)
 627         (let* ((b (match-beginning 0))
 628                (e (+ b 2))
 629                (l (split-file-name file))
 630                (dir (car l))
 631                (base (cadr l)))
 632           (LilyPond-command-expand
 633            (concat (substring string 0 b)
 634                    dir
 635                    base
 636                    (let ((entry (assoc (substring string b e)
 637                                        LilyPond-expand-alist)))
 638                      (if entry (cdr entry) ""))
 639                    (substring string e))
 640            file))
 641       string)))
 642
 643 (defun LilyPond-shell-process (name buffer command)
 644   (let ((old (current-buffer)))
 645     (switch-to-buffer-other-window buffer)
 646     ;; If we empty the buffer don't see messages scroll by.
 647     ;; (erase-buffer)
 648
 649     (start-process-shell-command name buffer command)
 650     (switch-to-buffer-other-window old)))
 651
 652
 653 (defun LilyPond-command (name file)
 654   "Run command NAME on the file you get by calling FILE.
 655
 656 FILE is a function return a file name.  It has one optional argument,
 657 the extension to use on the file.
 658
 659 Use the information in LilyPond-command-alist to determine how to run the
 660 command."
 661
 662   (let ((entry (assoc name LilyPond-command-alist)))
 663     (if entry
 664         (let ((command (LilyPond-command-expand (cadr entry)
 665                                                 (apply file nil)))
 666               (jobs nil)
 667               (job-string "no jobs"))
 668           (if (member name (list "View" "ViewPS"))
 669               ;; is USR1 a right signal for viewps?
 670               (let ((buffer-xdvi (get-buffer-create (concat "*" name "*"))))
 671                 ;; what if XEDITOR is set to gedit or so, should we steal it?
 672                 (if (not (getenv "XEDITOR"))
 673                     (setenv "XEDITOR" "emacsclient --no-wait +%l:%c %f"))
 674                 (if LilyPond-kick-xdvi
 675                   (let ((process-xdvi (get-buffer-process buffer-xdvi)))
 676                     (if process-xdvi
 677                         (signal-process (process-id process-xdvi) 'SIGUSR1)
 678                       (LilyPond-shell-process name buffer-xdvi command)))
 679                   (LilyPond-shell-process name buffer-xdvi command)))
 680             (progn
 681               (if (string-equal name "Midi")
 682                   (progn
 683                     (setq command (concat LilyPond-midi-command " " (LilyPond-string-current-midi)))
 684                     (if (LilyPond-kill-midi)
 685                         (setq job-string nil)))) ; either stop or start playing
 686               (if (string-equal name "MidiAll")
 687                   (progn
 688                     (setq command (concat LilyPond-all-midi-command " " (LilyPond-string-all-midi)))
 689                     (LilyPond-kill-midi))) ; stop and start playing
 690               (if (and (member name (list "Midi" "MidiAll")) job-string)
 691                   (if (file-newer-than-file-p
 692                        (LilyPond-get-master-file)
 693                        (concat (substring (LilyPond-get-master-file) 0 -3) ".midi"))
 694                       (if (y-or-n-p "Midi older than source. Reformat midi?")
 695                           (progn
 696                             (LilyPond-command-formatmidi)
 697                             (while (LilyPond-running)
 698                               (message "Starts playing midi once it is built.")
 699                               (sit-for 0 100))))))
 700               (if (member name (list "LilyPond" "TeX" "2Midi" "2PS" "2Dvi"
 701                                      "Book" "LaTeX"))
 702                   (if (setq jobs (LilyPond-running))
 703                       (progn
 704                         (setq job-string "Process") ; could also suggest compiling after process has ended
 705                         (while jobs
 706                           (setq job-string (concat job-string " \"" (pop jobs) "\"")))
 707                         (setq job-string (concat job-string " is already running; kill it to proceed "))
 708                         (if (y-or-n-p job-string)
 709                             (progn
 710                               (setq job-string "no jobs")
 711                               (LilyPond-kill-jobs)
 712                               (while (LilyPond-running)
 713                                 (sit-for 0 100)))
 714                           (setq job-string nil)))))
 715
 716               (setq LilyPond-command-next
 717                     (let* ((entry (assoc name LilyPond-command-alist))
 718                            (next-command (nth 3 (cdr entry))))
 719                       (or next-command
 720                           LilyPond-command-default)))
 721
 722               (if (string-equal job-string "no jobs")
 723                   (LilyPond-compile-file command name))))))))
 724
 725 (defun LilyPond-mark-active ()
 726   "Check if there is an active mark."
 727   (and transient-mark-mode
 728        (if (string-match "XEmacs\\|Lucid" emacs-version) (mark) mark-active)))
 729
 730 (defun LilyPond-temp-directory ()
 731   "Temporary file directory for Commands on Region."
 732   (interactive)
 733   (if (string-match "XEmacs\\|Lucid" emacs-version)
 734       (concat (temp-directory) "/")
 735     temporary-file-directory))
 736
 737 ;;; Keymap
 738
 739 (defvar LilyPond-mode-map ()
 740   "Keymap used in `LilyPond-mode' buffers.")
 741
 742 ;; Note:  if you make changes to the map, you must do
 743 ;;    M-x set-variable LilyPond-mode-map nil
 744 ;;    M-x eval-buffer
 745 ;;    M-x LilyPond-mode
 746 ;; to let the changest take effect
 747
 748 (if LilyPond-mode-map
 749     ()
 750   (setq LilyPond-mode-map (make-sparse-keymap))
 751   ;; Put keys to LilyPond-command-alist and fetch them from there somehow.
 752   (define-key LilyPond-mode-map "\C-c\C-l" 'LilyPond-command-lilypond)
 753   (define-key LilyPond-mode-map "\C-c\C-r" 'LilyPond-command-region)
 754   (define-key LilyPond-mode-map "\C-c\C-b" 'LilyPond-command-buffer)
 755   (define-key LilyPond-mode-map "\C-c\C-k" 'LilyPond-kill-jobs)
 756   (define-key LilyPond-mode-map "\C-c\C-c" 'LilyPond-command-master)
 757   (define-key LilyPond-mode-map "\C-cm" 'LilyPond-command-formatmidi)
 758   (define-key LilyPond-mode-map "\C-c\C-d" 'LilyPond-command-formatdvi)
 759   (define-key LilyPond-mode-map "\C-c\C-f" 'LilyPond-command-formatps)
 760   (define-key LilyPond-mode-map "\C-c\C-g" 'LilyPond-command-formatgnome)
 761   (define-key LilyPond-mode-map "\C-c\C-s" 'LilyPond-command-smartview)
 762   (define-key LilyPond-mode-map "\C-c\C-v" 'LilyPond-command-view)
 763   (define-key LilyPond-mode-map "\C-c\C-p" 'LilyPond-command-viewps)
 764   (define-key LilyPond-mode-map [(control c) return] 'LilyPond-command-current-midi)
 765   (define-key LilyPond-mode-map [(control c) (control return)] 'LilyPond-command-all-midi)
 766   (define-key LilyPond-mode-map "\C-x\C-s" 'LilyPond-save-buffer)
 767   (define-key LilyPond-mode-map "\C-cb" 'LilyPond-what-beat)
 768   (define-key LilyPond-mode-map "\C-cf" 'font-lock-fontify-buffer)
 769   (define-key LilyPond-mode-map "\C-ci" 'LilyPond-insert-tag-current)
 770   ;; the following will should be overriden by Lilypond Quick Insert Mode
 771   (define-key LilyPond-mode-map "\C-cq" 'LilyPond-quick-insert-mode)
 772   (define-key LilyPond-mode-map "\C-c;" 'LilyPond-comment-region)
 773   (define-key LilyPond-mode-map ")" 'LilyPond-electric-close-paren)
 774   (define-key LilyPond-mode-map ">" 'LilyPond-electric-close-paren)
 775   (define-key LilyPond-mode-map "}" 'LilyPond-electric-close-paren)
 776   (define-key LilyPond-mode-map "]" 'LilyPond-electric-close-paren)
 777   (define-key LilyPond-mode-map "|" 'LilyPond-electric-bar)
 778   (if (string-match "XEmacs\\|Lucid" emacs-version)
 779       (define-key LilyPond-mode-map [iso-left-tab] 'LilyPond-autocompletion)
 780     (define-key LilyPond-mode-map [iso-lefttab] 'LilyPond-autocompletion))
 781   (define-key LilyPond-mode-map "\C-c\t" 'LilyPond-info-index-search)
 782   )
 783
 784 ;;; Menu Support
 785
 786 ;;; This mode was originally LilyPond-quick-note-insert by Heikki Junes.
 787 ;;; The original version has been junked since CVS-1.97,
 788 ;;; in order to merge the efforts done by Nicolas Sceaux.
 789 ;;; LilyPond Quick Insert Mode is a major mode, toggled by C-c q.
 790 (defun LilyPond-quick-insert-mode ()
 791   "Insert notes with fewer key strokes by using a simple keyboard piano."
 792   (interactive)
 793   (progn
 794     (message "Invoke (C-c q) from keyboard. If you still see this message,") (sit-for 5 0)
 795     (message "then you have not installed LilyPond Quick Insert Mode (lyqi).") (sit-for 5 0)
 796     (message "Download lyqi from http://nicolas.sceaux.free.fr/lilypond/lyqi.html,") (sit-for 5 0)
 797     (message "see installation instructions from lyqi's README -file.") (sit-for 5 0)
 798     (message "You need also eieio (Enhanced Integration of Emacs Interpreted Objects).") (sit-for 5 0)
 799     (message "Download eieio from http://cedet.sourceforge.net/eieio.shtml,") (sit-for 5 0)
 800     (message "see installation instructions from eieio's INSTALL -file.") (sit-for 5 0)
 801     (message "")
 802     ))
 803
 804 (defun LilyPond-pre-word-search ()
 805   "Fetch the alphabetic characters and \\ in front of the cursor."
 806   (let ((pre "")
 807         (prelen 0)
 808         (ch (char-before (- (point) 0))))
 809     (while (and ch (or (and (>= ch 65) (<= ch 90))  ; not bolp, A-Z
 810                        (and (>= ch 97) (<= ch 122)) ; a-z
 811                        (= ch 92)))                  ; \\
 812       (setq pre (concat (char-to-string ch) pre))
 813       (setq prelen (+ prelen 1))
 814       (setq ch (char-before (- (point) prelen))))
 815     pre))
 816
 817 (defun LilyPond-post-word-search ()
 818   "Fetch the alphabetic characters behind the cursor."
 819   (let ((post "")
 820         (postlen 0)
 821         (ch (char-after (+ (point) 0))))
 822     (while (and ch (or (and (>= ch 65) (<= ch 90))    ; not eolp, A-Z
 823                        (and (>= ch 97) (<= ch 122)))) ; a-z
 824       (setq post (concat post (char-to-string ch)))
 825       (setq postlen (+ postlen 1))
 826       (setq ch (char-after (+ (point) postlen))))
 827     post))
 828
 829 (defun LilyPond-autocompletion ()
 830   "Show completions in mini-buffer for the given word."
 831   (interactive)
 832   (let ((pre (LilyPond-pre-word-search))
 833         (post (LilyPond-post-word-search))
 834         (compsstr ""))
 835     ;; insert try-completion and show all-completions
 836     (if (> (length pre) 0)
 837         (progn
 838           (setq trycomp (try-completion pre (LilyPond-add-dictionary-word ())))
 839           (if (char-or-string-p trycomp)
 840               (if (string-equal (concat pre post) trycomp)
 841                   (goto-char (+ (point) (length post)))
 842                 (progn
 843                   (delete-region (point) (+ (point) (length post)))
 844                   (insert (substring trycomp (length pre) nil))))
 845             (progn
 846               (delete-region (point) (+ (point) (length post)))
 847               (font-lock-fontify-buffer))) ; only inserting fontifies
 848
 849         (setq complist (all-completions pre (LilyPond-add-dictionary-word ())))
 850         (while (> (length complist) 0)
 851           (setq compsstr (concat compsstr "\"" (car complist) "\" "))
 852           (setq complist (cdr complist)))
 853         (message compsstr)
 854         (sit-for 0 100)))))
 855
 856 (defun LilyPond-info ()
 857   "Launch Info for lilypond."
 858   (interactive)
 859   (info "lilypond"))
 860
 861 (defun LilyPond-music-glossary-info ()
 862   "Launch Info for music-glossary."
 863   (interactive)
 864   (info "music-glossary"))
 865
 866 (defun LilyPond-internals-info ()
 867   "Launch Info for lilypond-internals."
 868   (interactive)
 869   (info "lilypond-internals"))
 870
 871 (defun LilyPond-info-index-search ()
 872   "In `*info*'-buffer, launch `info lilypond --index-search word-under-cursor'"
 873   (interactive)
 874   (let ((str (concat (LilyPond-pre-word-search) (LilyPond-post-word-search))))
 875     (if (and (> (length str) 0)
 876              (string-equal (substring str 0 1) "\\"))
 877         (setq str (substring str 1 nil)))
 878     (LilyPond-info)
 879     (Info-index str)))
 880
 881 (defun LilyPond-insert-tag-current (&optional word)
 882   "Set the current tag to be inserted."
 883   (interactive)
 884   (if word
 885       (setq LilyPond-insert-tag-current word))
 886   (if (memq LilyPond-insert-tag-current LilyPond-menu-keywords)
 887       (LilyPond-insert-tag)
 888     (message "No tag was selected from LilyPond->Insert tag-menu.")))
 889
 890 (defun LilyPond-insert-tag ()
 891   "Insert syntax for given tag. The definitions are in LilyPond-words-filename."
 892   (interactive)
 893   (setq b (find-file-noselect (LilyPond-words-filename) t t))
 894   (let ((word LilyPond-insert-tag-current)
 895         (found nil)
 896         (p nil)
 897         (query nil)
 898         (m (set-marker (make-marker) 1 (get-buffer b)))
 899         (distance (if (LilyPond-mark-active)
 900                       (abs (- (mark-marker) (point-marker))) 0))
 901        )
 902    ;; find the place first
 903    (if (LilyPond-mark-active)
 904        (goto-char (min (mark-marker) (point-marker))))
 905    (while (and (not found) (> (get-buffer-size b) (marker-position m)))
 906     (setq copy (car (copy-alist (list (eval (symbol-name (read m)))))))
 907     (if (string-equal word copy) (setq found t)))
 908    (if found (insert word))
 909    (if (> (get-buffer-size b) (marker-position m))
 910        (setq copy (car (copy-alist (list (eval (symbol-name (read m))))))))
 911    (if (not (string-equal "-" copy))
 912        (setq found nil))
 913    (while (and found (> (get-buffer-size b) (marker-position m)))
 914     ;; find next symbol
 915     (setq copy (car (copy-alist (list (eval (symbol-name (read m)))))))
 916     ;; check whether it is the word, or the word has been found
 917     (cond
 918      ((string-equal "-" copy) (setq found nil))
 919      ((string-equal "%" copy) (insert " " (read-string "Give Arguments: ")))
 920      ((string-equal "_" copy)
 921       (progn
 922        (setq p (point))
 923        (goto-char (+ p distance))))
 924      ((string-equal "\?" copy) (setq query t))
 925      ((string-equal "\!" copy) (setq query nil))
 926      ((string-equal "\\n" copy)
 927       (if (not query)
 928        (progn (LilyPond-indent-line) (insert "\n") (LilyPond-indent-line))))
 929      ((string-equal "{" copy)
 930       (if (not query)
 931           (progn (insert " { "))))
 932      ((string-equal "}" copy)
 933       (if (not query)
 934        (progn (insert " } ") (setq query nil) )))
 935      ((not query)
 936       (insert copy))
 937      (query
 938       (if (y-or-n-p (concat "Proceed with `" copy "'? "))
 939        (progn (insert copy) (setq query nil))))
 940    ))
 941    (if p (goto-char p))
 942    (kill-buffer b))
 943 )
 944
 945 (defun LilyPond-command-menu-entry (entry)
 946   ;; Return LilyPond-command-alist ENTRY as a menu item.
 947   (let ((name (car entry)))
 948     (cond ((and (string-equal name LilyPond-command-Print)
 949                 LilyPond-printer-list)
 950            (let ((command LilyPond-print-command)
 951                  (lookup 1))
 952              (append (list LilyPond-command-Print)
 953                      (mapcar 'LilyPond-command-menu-printer-entry
 954                              LilyPond-printer-list))))
 955           (t
 956            (vector name (list 'LilyPond-command-menu name) t)))))
 957
 958
 959 (easy-menu-define LilyPond-command-menu
 960   LilyPond-mode-map
 961   "Menu used in LilyPond mode."
 962   (append '("Command")
 963           '(("Command on"
 964              [ "Master File" LilyPond-command-select-master
 965                :keys "C-c C-c" :style radio
 966                :selected (eq LilyPond-command-current 'LilyPond-command-master) ]
 967              [ "Buffer" LilyPond-command-select-buffer
 968                :keys "C-c C-b" :style radio
 969                :selected (eq LilyPond-command-current 'LilyPond-command-buffer) ]
 970              [ "Region" LilyPond-command-select-region
 971                :keys "C-c C-r" :style radio
 972                :selected (eq LilyPond-command-current 'LilyPond-command-region) ]))
 973 ;;;       (let ((file 'LilyPond-command-on-current))
 974 ;;;         (mapcar 'LilyPond-command-menu-entry LilyPond-command-alist))
 975 ;;; Some kind of mapping which includes :keys might be more elegant
 976 ;;; Put keys to LilyPond-command-alist and fetch them from there somehow.
 977           '([ "LilyPond" LilyPond-command-lilypond t])
 978           '([ "TeX" (LilyPond-command (LilyPond-command-menu "TeX") 'LilyPond-get-master-file) ])
 979           '([ "2Dvi" LilyPond-command-formatdvi t])
 980           '([ "2PS" LilyPond-command-formatps t])
 981           '([ "2Midi" LilyPond-command-formatmidi t])
 982           '([ "Book" (LilyPond-command (LilyPond-command-menu "Book") 'LilyPond-get-master-file) ])
 983           '([ "LaTeX" (LilyPond-command (LilyPond-command-menu "LaTeX") 'LilyPond-get-master-file) ])
 984           '([ "Kill jobs" LilyPond-kill-jobs t])
 985           '("-----")
 986           '([ "SmartView" LilyPond-command-smartview t])
 987           '([ "View" LilyPond-command-view t])
 988           '([ "ViewPS" LilyPond-command-viewps t])
 989           '("-----")
 990           '([ "Midi (toggle)" LilyPond-command-current-midi t])
 991           '([ "Midi all" LilyPond-command-all-midi t])
 992           ))
 993
 994 (defun LilyPond-menu-keywords-item (arg)
 995   "Make vector for LilyPond-mode-keywords."
 996   (vector arg (list 'LilyPond-insert-tag-current arg) :style 'radio :selected (list 'eq 'LilyPond-insert-tag-current arg)))
 997
 998 (defun LilyPond-menu-keywords ()
 999   "Make Insert Tag menu.
1000
1001 The Insert Tag -menu is splitted into parts if it is long enough."
1002
1003   (let ((li (mapcar 'LilyPond-menu-keywords-item LilyPond-menu-keywords))
1004         (w (round (sqrt (length LilyPond-menu-keywords))))
1005         (splitted '())
1006         (imin 0) imax lw rw)
1007     (while (< imin (length LilyPond-menu-keywords))
1008       (setq imax (- (min (+ imin w) (length LilyPond-menu-keywords)) 1))
1009       (setq lw (nth imin LilyPond-menu-keywords))
1010       (setq rw (nth imax LilyPond-menu-keywords))
1011       (add-to-list 'splitted
1012          (let ((l (list (concat (substring lw 0 (min 7 (length lw)))
1013                                 " ... "
1014                                 (substring rw 0 (min 7 (length rw)))))))
1015            (while (<= imin imax)
1016              (add-to-list 'l (nth imin li))
1017              (setq imin (1+ imin)))
1018            (reverse l))))
1019     (if (> (length LilyPond-menu-keywords) 12) (reverse splitted) li)))
1020
1021 ;;; LilyPond-mode-menu should not be interactive, via "M-x LilyPond-<Tab>"
1022 (easy-menu-define LilyPond-mode-menu
1023   LilyPond-mode-map
1024   "Menu used in LilyPond mode."
1025   (append '("LilyPond")
1026           '(["Add index menu" LilyPond-add-imenu-menu])
1027           (list (cons "Insert tag"
1028                 (cons ["Previously selected" LilyPond-insert-tag-current t]
1029                 (cons "-----"
1030                       (LilyPond-menu-keywords)))))
1031           '(("Miscellaneous"
1032              ["Autocompletion"   LilyPond-autocompletion t]
1033              ["(Un)comment Region" LilyPond-comment-region t]
1034              ["Refontify buffer" font-lock-fontify-buffer t]
1035              "-----"
1036              ["Quick Insert Mode"  LilyPond-quick-insert-mode :keys "C-c q"]
1037              ))
1038           '(("Info"
1039              ["LilyPond" LilyPond-info t]
1040              ["LilyPond index-search" LilyPond-info-index-search t]
1041              ["Music Glossary" LilyPond-music-glossary-info t]
1042              ["LilyPond internals" LilyPond-internals-info t]
1043              ))
1044           ))
1045
1046 (defconst LilyPond-imenu-generic-re "^\\([a-zA-Z]+\\) *="
1047   "Regexp matching Identifier definitions.")
1048
1049 (defvar LilyPond-imenu-generic-expression
1050   (list (list nil LilyPond-imenu-generic-re 1))
1051   "Expression for imenu")
1052
1053 (defun LilyPond-command-select-master ()
1054   (interactive)
1055   (message "Next command will be on the master file")
1056   (setq LilyPond-command-current 'LilyPond-command-master))
1057
1058 (defun LilyPond-command-select-buffer ()
1059   (interactive)
1060   (message "Next command will be on the buffer")
1061   (setq LilyPond-command-current 'LilyPond-command-buffer))
1062
1063 (defun LilyPond-command-select-region ()
1064   (interactive)
1065   (message "Next command will be on the region")
1066   (setq LilyPond-command-current 'LilyPond-command-region))
1067
1068 (defun LilyPond-command-menu (name)
1069   ;; Execute LilyPond-command-alist NAME from a menu.
1070   (let ((LilyPond-command-force name))
1071     (if (eq LilyPond-command-current 'LilyPond-command-region)
1072         (if (eq (mark t) nil)
1073             (progn (message "The mark is not set now") (sit-for 0 500))
1074           (progn (if (not (not (LilyPond-mark-active)))
1075                      (progn (message "Region is not active, using region between inactive mark and current point.") (sit-for 0 500)))
1076                  (LilyPond-command-region (mark t) (point))))
1077       (funcall LilyPond-command-current))))
1078
1079 (defun LilyPond-add-imenu-menu ()
1080   (interactive)
1081   "Add an imenu menu to the menubar."
1082   (if (not LilyPond-imenu)
1083       (progn
1084         (imenu-add-to-menubar "Index")
1085         (redraw-frame (selected-frame))
1086         (setq LilyPond-imenu t))
1087     (message "%s" "LilyPond-imenu already exists.")))
1088 (put 'LilyPond-add-imenu-menu 'menu-enable '(not LilyPond-imenu))
1089
1090 (defun LilyPond-mode ()
1091   "Major mode for editing LilyPond music files.
1092
1093 This mode knows about LilyPond keywords and line comments, not about
1094 indentation or block comments.  It features easy compilation, error
1095 finding and viewing of a LilyPond source buffer or region.
1096
1097 COMMANDS
1098 \\{LilyPond-mode-map}
1099 VARIABLES
1100
1101 LilyPond-command-alist\t\talist from name to command
1102 LilyPond-xdvi-command\t\tcommand to display dvi files -- bit superfluous"
1103   (interactive)
1104   ;; set up local variables
1105   (kill-all-local-variables)
1106
1107   (make-local-variable 'font-lock-defaults)
1108   (setq font-lock-defaults '(LilyPond-font-lock-keywords))
1109
1110   ;; string and comments are fontified explicitly
1111   (make-local-variable 'font-lock-keywords-only)
1112   (setq font-lock-keywords-only t)
1113
1114   ;; Multi-line font-locking needs Emacs 21.1 or newer.
1115   ;; For older versions there is hotkey "C-c f".
1116   (make-local-variable 'font-lock-multiline)
1117   (setq font-lock-multiline t)
1118
1119   (make-local-variable 'paragraph-separate)
1120   (setq paragraph-separate "^[ \t]*$")
1121
1122   (make-local-variable 'paragraph-start)
1123   (setq paragraph-start "^[ \t]*$")
1124
1125   (make-local-variable 'comment-start)
1126   (setq comment-start "%")
1127
1128   (make-local-variable 'comment-start-skip)
1129   (setq comment-start-skip "%{? *")
1130
1131   (make-local-variable 'comment-end)
1132   (setq comment-end "")
1133
1134   (make-local-variable 'block-comment-start)
1135   (setq block-comment-start "%{")
1136
1137   (make-local-variable 'block-comment-end)
1138   (setq block-comment-end   "%}")
1139
1140   (make-local-variable 'indent-line-function)
1141   (setq indent-line-function 'LilyPond-indent-line)
1142
1143   (LilyPond-mode-set-syntax-table '(?\< ?\> ?\{ ?\}))
1144   (setq major-mode 'LilyPond-mode)
1145   (setq mode-name "LilyPond")
1146   (setq local-abbrev-table LilyPond-mode-abbrev-table)
1147   (use-local-map LilyPond-mode-map)
1148
1149   ;; In XEmacs imenu was synched up with: FSF 20.4
1150   (make-local-variable 'imenu-generic-expression)
1151   (setq imenu-generic-expression LilyPond-imenu-generic-expression)
1152   ;; (imenu-add-to-menubar "Index") ; see LilyPond-add-imenu-menu
1153
1154   ;; In XEmacs one needs to use 'easy-menu-add'.
1155   (if (string-match "XEmacs\\|Lucid" emacs-version)
1156       (progn
1157         (easy-menu-add LilyPond-mode-menu)
1158         (easy-menu-add LilyPond-command-menu)))
1159
1160   ;; Use Command on Region even for inactive mark (region).
1161   (if (string-match "XEmacs\\|Lucid" emacs-version)
1162       (setq zmacs-regions nil)
1163     (setq mark-even-if-inactive t))
1164
1165   ;; Context dependent syntax tables in LilyPond-mode
1166   (make-local-hook 'post-command-hook) ; XEmacs requires
1167   (add-hook 'post-command-hook 'LilyPond-mode-context-set-syntax-table nil t)
1168
1169   ;; Turn on paren-mode buffer-locally, i.e., in LilyPond-mode
1170   (if (string-match "XEmacs\\|Lucid" emacs-version)
1171       (progn
1172         (make-local-variable 'paren-mode)
1173         (paren-set-mode 'paren)
1174         (make-local-variable 'blink-matching-paren)
1175         (setq blink-matching-paren t)
1176         )
1177     (progn
1178       (make-local-variable 'blink-matching-paren-on-screen)
1179       (setq blink-matching-paren-on-screen t)
1180      ))
1181
1182   ;; run the mode hook. LilyPond-mode-hook use is deprecated
1183   (run-hooks 'LilyPond-mode-hook))
1184
1185 (defun LilyPond-version ()
1186   "Echo the current version of `LilyPond-mode' in the minibuffer."
1187   (interactive)
1188   (message "Using `LilyPond-mode' version %s" LilyPond-version))
1189
1190 (load-library "lilypond-font-lock")
1191 (load-library "lilypond-indent")
1192 (load-library "lilypond-what-beat")
1193
1194 (defun LilyPond-guile ()
1195   (interactive)
1196   (require 'ilisp)
1197   (guile "lilyguile" (LilyPond-command-expand (cadr (assoc "2Dvi" LilyPond-command-alist))
1198                                               (funcall 'LilyPond-get-master-file)))
1199   (comint-default-send (ilisp-process) "(define-module (*anonymous-ly-0*))")
1200   (comint-default-send (ilisp-process) "(set! %load-path (cons \"/usr/share/ilisp/\" %load-path))")
1201   (comint-default-send (ilisp-process) "(use-modules (guile-user) (guile-ilisp))")
1202   (comint-default-send (ilisp-process) "(newline)"))
1203
1204 (provide 'lilypond-mode)
1205 ;;; lilypond-mode.el ends here
1206