X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lilypond-mode.el;h=6b5fea2f3e5ec6fc6c6fd3ab0b0b94131049936f;hb=bd621ce77744a56b6d70ddd9eeae88ead5e7ffe4;hp=8a4c7ccf6fa0c5419c6403b68fd8e3e67ff073ad;hpb=28b274e6d311e56087794a973e82ebd1185f923e;p=lilypond.git diff --git a/lilypond-mode.el b/lilypond-mode.el index 8a4c7ccf6f..6b5fea2f3e 100644 --- a/lilypond-mode.el +++ b/lilypond-mode.el @@ -1,156 +1,225 @@ +;;; ;;; lilypond-mode.el --- Major mode for editing GNU LilyPond music scores +;;; +;;; source file of the GNU LilyPond music typesetter +;;; +;;; (c) 1999--2003 Jan Nieuwenhuizen +;;; +;;; Changed 2001--2003 Heikki Junes +;;; * Add PS-compilation, PS-viewing and MIDI-play (29th Aug 2001) +;;; * Keyboard shortcuts (12th Sep 2001) +;;; * Inserting tags, inspired on sgml-mode (11th Oct 2001) +;;; * Autocompletion & Info (23rd Nov 2002) +;;; +;;; Changed 2002 Carlos Betancourt +;;; * Added spanish-note-replacements -;; Copyright (C) 1992,1993,1994 Tim Peters - -;; Author: 1999: Jan Nieuwenhuizen -;; Author: 1997: Han-Wen Nienhuys -;; Author: 1995-1996 Barry A. Warsaw -;; 1992-1994 Tim Peters -;; Created: Feb 1992 -;; Version: 0.0 -;; Last Modified: 12SEP97 -;; Keywords: mudela languages music - -;; This software is provided as-is, without express or implied -;; warranty. Permission to use, copy, modify, distribute or sell this -;; software, without fee, for any purpose and by any individual or -;; organization, is hereby granted, provided that the above copyright -;; notice and this paragraph appear in all copies. - -;; This started out as a cannabalised version of python-mode.el, by hwn -;; For changes see the LilyPond ChangeLog -;; -;; TODO: -;; * lily/ly/lilypond? -;; * syntax -;; - should handle block comments too. -;; - handle lexer modes (\header, \melodic, \lyric) etc. -;; - indentation -;; - notenames? -;; - fontlock: \melodic \melodic - - -(defconst lily-version "1.3.19" - "`lilypond-mode' version number.") - -(defconst lily-help-address "hanwen@cs.uu.nl" - "Address accepting submission of bug reports.") +;;; Inspired on auctex -(defconst lily-font-lock-keywords - (let* ((keywords '("spanrequest" "simultaneous" "sequential" "accepts" - "alternative" "bar" "breathe" - "cadenza" "chordmodifiers" "chords" "clef" "cm" "consists" - "consistsend" "context" - "duration" "font" "grace" "header" "in" "lyrics" - "key" "keysignature" "mark" "musicalpitch" - "time" "times" "midi" "mm" "name" "notenames" - "notes" "partial" "paper" "penalty" "property" "pt" - "relative" "remove" "repeat" "repetitions" "addlyrics" - "scm" "scmfile" "score" "script" - "shape" "skip" "textscript" "tempo" "translator" "transpose" - "type" "version" - )) - (kwregex (mapconcat (lambda (x) (concat "\\\\" x)) keywords "\\|"))) - - (list - (concat ".\\(" kwregex "\\)[^a-zA-Z]") - (concat "^\\(" kwregex "\\)[^a-zA-Z]") - '(".\\(\\\\[a-zA-Z][a-zA-Z]*\\)" 1 font-lock-variable-name-face) - '("^[\t ]*\\([a-zA-Z][_a-zA-Z]*\\) *=" 1 font-lock-variable-name-face) - )) - "Additional expressions to highlight in Mudela mode.") - -;; define a mode-specific abbrev table for those who use such things -(defvar lilypond-mode-abbrev-table nil - "Abbrev table in use in `lilypond-mode' buffers.") - -(define-abbrev-table 'lilypond-mode-abbrev-table nil) - -(defvar lilypond-mode-hook nil - "*Hook called by `lilypond-mode'.") - -(defvar lily-mode-syntax-table nil - "Syntax table used in `lilypond-mode' buffers.") - -;; -(if lily-mode-syntax-table - () - (setq lily-mode-syntax-table (make-syntax-table)) - (mapcar (function - (lambda (x) (modify-syntax-entry - (car x) (cdr x) lily-mode-syntax-table))) - '(( ?\( . "." ) ( ?\) . "." ) - ( ?\[ . "." ) ( ?\] . "." ) - ( ?\{ . "(}" ) ( ?\} . "){" ) - ( ?\< . "(>" )( ?\> . ")>") - ( ?\$ . "." ) ( ?\% . "." ) ( ?\& . "." ) - ( ?\* . "." ) ( ?\+ . "." ) ( ?\- . "." ) - ( ?\/ . "." ) ( ?\= . "." ) - ( ?\| . "." ) (?\\ . "\\" ) - ( ?\_ . "." ) - ( ?\' . "w") - ( ?\" . "\"" ) - ( ?\% . "<") - ( ?\n . ">") - -; FIXME -; ( ?% . ". 124b" ) -; ( ?{ . ". 23" ) - )) - - ) - -(defconst lily-imenu-generic-re "^\\([a-zA-Z_][a-zA-Z0-9_]*\\) *=" - "Regexp matching Identifier definitions.") +;;; Look lilypond-init.el or Documentation/topdocs/INSTALL.texi +;;; for installing instructions. -;; Sadly we need this for a macro in Emacs 19. -(eval-when-compile - ;; Imenu isn't used in XEmacs, so just ignore load errors. - (condition-case () - (require 'imenu) - (error nil))) +(require 'easymenu) +(require 'compile) -(defvar lily-imenu-generic-expression - (list (list nil lily-imenu-generic-re 1)) - "Expression for imenu") +(defconst LilyPond-version "1.7.18" + "`LilyPond-mode' version number.") +(defconst LilyPond-help-address "bug-lilypond@gnu.org" + "Address accepting submission of bug reports.") -;;; we're using some handy compile commands -(require 'compile) +(defvar LilyPond-mode-hook nil + "*Hook called by `LilyPond-mode'.") -(defcustom lily-command "lilypond" - "* LilyPond executable." - :type 'string - :group 'lily) +(defvar LilyPond-region-file-prefix "emacs-lily" + "File prefix for commands on buffer or region.") -(defcustom lily-parameters "" - "*." - :type 'string - :group 'lily) +;; FIXME: find ``\score'' in buffers / make settable? +(defun LilyPond-master-file () + ;; duh + (buffer-file-name)) -(defvar lily-regexp-alist +(defvar LilyPond-kick-xdvi nil + "If true, no simultaneous xdvi's are started, but reload signal is sent.") + +(defvar LilyPond-command-history nil + "Command history list.") + +(defvar LilyPond-regexp-alist '(("\\([a-zA-Z]?:?[^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 2)) "Regexp used to match LilyPond errors. See `compilation-error-regexp-alist'.") -(defcustom lily-tex-command "tex" - "*." +(defcustom LilyPond-include-path ".:/tmp" + "* LilyPond include path." :type 'string - :group 'lily) + :group 'LilyPond) -(defcustom lily-xdvi-command "xdvi" - "*." - :type 'string - :group 'lily) +(defun LilyPond-words-filename () + "The file containing LilyPond \keywords \Identifiers and ReservedWords. +Finds file lilypond-words from load-path." + (let ((fn nil) + (lp load-path) + (words-file "lilypond.words")) + (while (and (> (length lp) 0) (not fn)) + (setq fn (concat (car lp) "/" words-file)) + (if (not (file-readable-p fn)) + (progn (setq fn nil) (setq lp (cdr lp))))) + (if (not fn) + (progn (message "Warning: `lilypond.words' not found in `load-path'. See `lilypond-init.el'.") + (sit-for 5 0))) + fn)) + +(defun LilyPond-add-dictionary-word (x) + "Contains all words: \keywords \Identifiers and ReservedWords." + (nconc '(("" . 1)) x)) + +;; creates dictionary if empty +(if (and (eq (length (LilyPond-add-dictionary-word ())) 1) + (not (eq (LilyPond-words-filename) nil))) + (progn + (setq b (find-file-noselect (LilyPond-words-filename) t t)) + (setq m (set-marker (make-marker) 1 (get-buffer b))) + (setq i 1) + (while (> (buffer-size b) (marker-position m)) + (setq i (+ i 1)) + (setq copy (copy-alist (list (eval (symbol-name (read m)))))) + (setcdr copy i) + (LilyPond-add-dictionary-word (list copy))) + (kill-buffer b))) + +(defconst LilyPond-keywords + (let ((wordlist ()) + (co (all-completions "" (LilyPond-add-dictionary-word ())))) + (progn + (while (> (length co) 0) + (if (> (length (car co)) 1) + (if (and (string-equal "\\" (substring (car co) 0 1)) + (string-equal (downcase (car co)) (car co))) + (add-to-list 'wordlist (car co)))) + (setq co (cdr co))) + (if (eq (length wordlist) 0) + (setq wordlist '("\\score"))) ; add \keywords to lilypond.words + wordlist)) + "LilyPond \\keywords") + +(defconst LilyPond-identifiers + (let ((wordlist ()) + (co (all-completions "" (LilyPond-add-dictionary-word ())))) + (progn + (while (> (length co) 0) + (if (> (length (car co)) 1) + (if (and (string-equal "\\" (substring (car co) 0 1)) + (not (string-equal (downcase (car co)) (car co)))) + (add-to-list 'wordlist (car co)))) + (setq co (cdr co))) + (if (eq (length wordlist) 0) + (setq wordlist '("\\voiceOne"))) ; add \Identifiers to lilypond.words + wordlist)) + "LilyPond \\Identifiers") + +(defconst LilyPond-reserved-words + (let ((wordlist ()) + (co (all-completions "" (LilyPond-add-dictionary-word ())))) + (progn + (while (> (length co) 0) + (if (> (length (car co)) 0) + (if (not (string-equal "\\" (substring (car co) 0 1))) + (add-to-list 'wordlist (car co)))) + (setq co (cdr co))) + (if (eq (length wordlist) 0) + (setq wordlist '("Staff"))) ; add ReservedWords to lilypond.words + wordlist)) + "LilyPond ReservedWords") -(defun lily-compile-file (command parameters file) - ;; Setting process-setup-function makes exit-message-function work - ;; even when async processes aren't supported. - (let ((command-args (concat command " " parameters " " file))) - (compile-internal command-args "No more errors" "LilyPond"))) +(defun LilyPond-check-files (derived originals extensions) + "Check that DERIVED is newer than any of the ORIGINALS. +Try each original with each member of EXTENSIONS, in all directories +in LilyPond-include-path." + (let ((found nil) + (regexp (concat "\\`\\(" + (mapconcat (function (lambda (dir) + (regexp-quote (expand-file-name dir)))) + LilyPond-include-path "\\|") + "\\).*\\(" + (mapconcat 'regexp-quote originals "\\|") + "\\)\\.\\(" + (mapconcat 'regexp-quote extensions "\\|") + "\\)\\'")) + (buffers (buffer-list))) + (while buffers + (let* ((buffer (car buffers)) + (name (buffer-file-name buffer))) + (setq buffers (cdr buffers)) + (if (and name (string-match regexp name)) + (progn + (and (buffer-modified-p buffer) + (or (not LilyPond-save-query) + (y-or-n-p (concat "Save file " + (buffer-file-name buffer) + "? "))) + (save-excursion (set-buffer buffer) (save-buffer))) + (if (file-newer-than-file-p name derived) + (setq found t)))))) + found)) + +(defun LilyPond-running () + "Check the currently running LilyPond compiling jobs." + (interactive) + (let ((process-names (list "lilypond" "tex" "2dvi" "2ps" "2midi" + "book" "latex")) + (running nil)) + (while (setq process-name (pop process-names)) + (setq process (get-process process-name)) + (if (and process + (eq (process-status process) 'run)) + (push process-name running))) + running)) ; return the running jobs + +(defun LilyPond-midi-running () + "Check the currently running Midi processes." + (interactive) + (let ((process-names (list "midi" "midiall")) + (running nil)) + (while (setq process-name (pop process-names)) + (setq process (get-process process-name)) + (if (and process + (eq (process-status process) 'run)) + (push process-name running))) + running)) ; return the running jobs + +(defun LilyPond-kill-jobs () + "Kill the currently running LilyPond compiling jobs." + (interactive) + (let ((process-names (LilyPond-running)) + (killed nil)) + (while (setq process-name (pop process-names)) + (quit-process (get-process process-name) t) + (push process-name killed)) + killed)) ; return the killed jobs + +(defun LilyPond-kill-midi () + "Kill the currently running midi processes." + (let ((process-names (LilyPond-midi-running)) + (killed nil)) + (while (setq process-name (pop process-names)) + (quit-process (get-process process-name) t) + (push process-name killed)) + killed)) ; return the killed jobs + +;; URG, should only run LilyPond-compile for LilyPond +;; not for tex,xdvi (ly2dvi?) +(defun LilyPond-compile-file (command name) + ;; We maybe should know what we run here (Lily, ly2dvi, tex) + ;; and adjust our error-matching regex ? + (compile-internal command "No more errors" name )) ;; do we still need this, now that we're using compile-internal? -(defun lily-save-buffer () - (if (buffer-modified-p) (save-buffer))) +(defun LilyPond-save-buffer () + "Save buffer and set default command for compiling." + (interactive) + (if (buffer-modified-p) + (progn (save-buffer) + (setq LilyPond-command-default "LilyPond")))) ;;; return (dir base ext) (defun split-file-name (name) @@ -164,155 +233,828 @@ (list dir (substring file 0 (- i 1)) (substring file i (length file))) (list dir file "")))) -;;;###autoload -(defun lily-eval-buffer () - "Run LilyPond on buffer." + +;; Should check whether in command-alist? +(defcustom LilyPond-command-default "LilyPond" + "Default command. Must identify a member of LilyPond-command-alist." + + :group 'LilyPond + :type 'string) +;;;(make-variable-buffer-local 'LilyPond-command-last) + +(defvar LilyPond-command-current 'LilyPond-command-master) +;;;(make-variable-buffer-local 'LilyPond-command-master) + + +;; If non-nil, LilyPond-command-query will return the value of this +;; variable instead of quering the user. +(defvar LilyPond-command-force nil) + +(defcustom LilyPond-xdvi-command "xdvi" + "Command used to display DVI files." + + :group 'LilyPond + :type 'string) + +(defcustom LilyPond-gv-command "gv -watch" + "Command used to display PS files." + + :group 'LilyPond + :type 'string) + +(defcustom LilyPond-midi-command "timidity" + "Command used to play MIDI files." + + :group 'LilyPond + :type 'string) + +(defcustom LilyPond-all-midi-command "timidity -ia" + "Command used to play MIDI files." + + :group 'LilyPond + :type 'string) + +(defun LilyPond-command-current-midi () + "Play midi corresponding to the current document." (interactive) - (let ((buffer (buffer-name))) - (if (buffer-file-name) - (progn - (lily-save-buffer) - (lily-compile-file lily-command lily-parameters (buffer-file-name))) - (progn - (error "Buffer %s is not associated with a file" buffer) - (lily-eval-region (min-point) (max-point)))))) + (LilyPond-command (LilyPond-command-menu "Midi") 'LilyPond-master-file)) -;;;###autoload -(defun lily-eval-region (start end) - "Run LilyPond on region." +(defun LilyPond-command-all-midi () + "Play midi corresponding to the current document." + (interactive) + (LilyPond-command (LilyPond-command-menu "MidiAll") 'LilyPond-master-file)) + +(defun count-rexp (start end rexp) + "Print number of found regular expressions in the region." (interactive "r") - (let ((basename "emacs-lily") - (suffix (if (string-match "^[\\]score" (buffer-substring start end)) - ".ly" - (if (< 50 (abs (- start end))) - ".fly" - ".sly")))) - (write-region start end (concat basename suffix) nil 'nomsg) - (lily-compile-file lily-command lily-parameters (concat basename suffix)))) - -(defun lily-running () - (let ((process (get-process "lilypond"))) - (and process - (eq (process-status process) 'run)))) - -(defun lily-tex-file (basename) - (call-process lily-tex-command nil t nil basename)) - -(defun lily-xdvi-file (basename) - (let ((outbuf (get-buffer-create "*lily-xdvi*")) - (name "xdvi") - (command (concat lily-xdvi-command " " basename))) - (if (get-process "xdvi") - ;; Don't open new xdvi window, but force redisplay - ;; We could make this an option. - (signal-process (process-id (get-process "xdvi")) 'SIGUSR1) - (if (fboundp 'start-process) - (let* ((process-environment (cons "EMACS=t" process-environment)) - (proc (start-process-shell-command name outbuf command))) - ;;(set-process-sentinel proc 'compilation-sentinel) - ;;(set-process-filter proc 'compilation-filter) - (set-marker (process-mark proc) (point) outbuf)) - ;;(setq compilation-in-progress (cons proc compilation-in-progress))) - - ;; No asynchronous processes available. - (message "Executing `%s'..." command) - ;; Fake modeline display as if `start-process' were run. - (setq mode-line-process ":run") - (force-mode-line-update) - (sit-for 0) ; Force redisplay - (call-process shell-file-name nil outbuf nil "-c" command) - (message "Executing `%s'...done" command))))) - - -;;;###autoload -(defun lily-xdvi-buffer () - "Run LilyPond, TeX and Xdvi on buffer." - (interactive) - - (let* ((split (split-file-name buffer-file-name)) - (dir (car split)) - (base (cadr split))) - - ;; we don't really need this... - (let ((tex (concat dir base ".tex")) - (dvi (concat dir base ".dvi"))) - (if (file-exists-p tex) (delete-file tex)) - (if (file-exists-p dvi) (delete-file dvi))) - - (lily-eval-buffer) - (set-buffer "*lilypond*") - - ;;(setq default-directory dir) - (while (lily-running) - (continue-process (get-process "lilypond"))) - (sit-for 0) ; Force redisplay + (save-excursion + (save-restriction + (narrow-to-region start end) + (goto-char (point-min)) + (count-matches rexp)))) + +(defun count-midi-words () + "Check number of midi-scores before the curser." + (interactive) + (count-rexp (point-min) (point-max) "\\\\midi")) + +(defun count-midi-words-backwards () + "Check number of midi-scores before the curser." + (interactive) + (count-rexp (point-min) (point) "\\\\midi")) + +(defun LilyPond-string-current-midi () + "Check the midi file of the following midi-score in the current document." + (interactive) + (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master) + (substring (LilyPond-master-file) 0 -3); suppose ".ly" + LilyPond-region-file-prefix)) + (allcount (string-to-number (substring (count-midi-words) 0 -12))) + (count (string-to-number (substring (count-midi-words-backwards) 0 -12)))) + (concat fnameprefix + (if (and (> allcount 1) (> count 0)) ; not first score + (if (eq count allcount) ; last score + (concat "-" (number-to-string (+ count -1))) + (concat "-" (number-to-string count)))) + ".midi"))) + +(defun LilyPond-string-all-midi () + "Return the midi files of the current document in ascending order." + (interactive) + (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master) + (substring (LilyPond-master-file) 0 -3); suppose ".ly" + LilyPond-region-file-prefix)) + (allcount (string-to-number (substring (count-midi-words) 0 -12)))) + (concat (if (> allcount 0) ; at least one midi-score + (concat fnameprefix ".midi ")) + (if (> allcount 1) ; more than one midi-score + (concat fnameprefix "-[1-9].midi ")) + (if (> allcount 9) ; etc. + (concat fnameprefix "-[1-9][0-9].midi")) + (if (> allcount 99) ; not first score + (concat fnameprefix "-[1-9][0-9][0-9].midi"))))) + +;; This is the major configuration variable. +(defcustom LilyPond-command-alist + ;; Should expand this to include possible keyboard shortcuts which + ;; could then be mapped to define-key and menu. + `( + ("LilyPond" . ("lilypond %s" . "LaTeX")) + ("TeX" . ("tex '\\nonstopmode\\input %t'" . "View")) + + ("2Dvi" . ("ly2dvi %s" . "View")) + ("2PS" . ("ly2dvi -P %s" . "ViewPS")) + ("2Midi" . ("lilypond -m %s" . "View")) + + ("Book" . ("lilypond-book %x" . "LaTeX")) + ("LaTeX" . ("latex '\\nonstopmode\\input %l'" . "View")) + + ;; point-n-click (arg: exits upop USR1) + ("SmartView" . ("xdvi %d" . "LilyPond")) + + ;; refreshes when kicked USR1 + ("View" . (,(concat LilyPond-xdvi-command " %d") . "LilyPond")) + ("ViewPS" . (,(concat LilyPond-gv-command " %p") . "LilyPond")) + + ;; The following are refreshed in LilyPond-command: + ;; - current-midi depends on cursor position and + ("Midi" . (,(concat LilyPond-midi-command " " (LilyPond-string-current-midi)) . "LilyPond" )) ; + ;; - all-midi depends on number of midi-score. + ("MidiAll" . (,(concat LilyPond-all-midi-command " " (LilyPond-string-all-midi)) . "LilyPond")) + ) + + "AList of commands to execute on the current document. + +The key is the name of the command as it will be presented to the +user, the value is a cons of the command string handed to the shell +after being expanded, and the next command to be executed upon +success. The expansion is done using the information found in +LilyPond-expand-list. +" + :group 'LilyPond + :type '(repeat (cons :tag "Command Item" + (string :tag "Key") + (cons :tag "How" + (string :tag "Command") + (string :tag "Next Key"))))) + +;; drop this? +(defcustom LilyPond-file-extensions '(".ly" ".sly" ".fly") + "*File extensions used by manually generated TeX files." + :group 'LilyPond + :type '(repeat (string :format "%v"))) + + +(defcustom LilyPond-expand-alist + '( + ("%s" . ".ly") + ("%t" . ".tex") + ("%d" . ".dvi") + ("%p" . ".ps") + ("%l" . ".tex") + ("%x" . ".tely") + ("%m" . ".midi") + ) - (if (= 0 (process-exit-status (get-process "lilypond"))) - (progn - (if (= 0 (lily-tex-file base)) - (lily-xdvi-file base)))))) - -;;;###autoload -(defun lily-xdvi-region (start end) - "Run LilyPond, TeX and Xdvi on region." + "Alist of expansion strings for LilyPond command names." + :group 'LilyPond + :type '(repeat (cons :tag "Alist item" + (string :tag "Symbol") + (string :tag "Expansion")))) + + +(defcustom LilyPond-command-Show "View" + "*The default command to show (view or print) a LilyPond file. +Must be the car of an entry in `LilyPond-command-alist'." + :group 'LilyPond + :type 'string) + (make-variable-buffer-local 'LilyPond-command-Show) + +(defcustom LilyPond-command-Print "Print" + "The name of the Print entry in LilyPond-command-Print." + :group 'LilyPond + :type 'string) + +(defun xLilyPond-compile-sentinel (process msg) + (if (and process + (= 0 (process-exit-status process))) + (setq LilyPond-command-default + (cddr (assoc LilyPond-command-default LilyPond-command-alist))))) + +;; FIXME: shouldn't do this for stray View/xdvi +(defun LilyPond-compile-sentinel (buffer msg) + (if (string-match "^finished" msg) + (setq LilyPond-command-default + (cddr (assoc LilyPond-command-default LilyPond-command-alist))))) + +;;(make-variable-buffer-local 'compilation-finish-function) +(setq compilation-finish-function 'LilyPond-compile-sentinel) + +(defun LilyPond-command-query (name) + "Query the user for what LilyPond command to use." + (let* ((default (cond ((if (string-equal name LilyPond-region-file-prefix) + (LilyPond-check-files (concat name ".tex") + (list name) + LilyPond-file-extensions) + (if (verify-visited-file-modtime (current-buffer)) + (if (buffer-modified-p) + (if (y-or-n-p "Save buffer before next command? ") + (LilyPond-save-buffer))) + (if (y-or-n-p "The command will be invoked to an already saved buffer. Revert it? ") + (revert-buffer t t))) + ;;"LilyPond" + LilyPond-command-default)) + (t LilyPond-command-default))) + + (completion-ignore-case t) + + (answer (or LilyPond-command-force + (completing-read + (concat "Command: (default " default ") ") + LilyPond-command-alist nil t nil 'LilyPond-command-history)))) + + ;; If the answer is "LilyPond" it will not be expanded to "LilyPond" + (let ((answer (car-safe (assoc answer LilyPond-command-alist)))) + (if (and answer + (not (string-equal answer ""))) + answer + default)))) + +(defun LilyPond-command-master () + "Run command on the current document." + (interactive) + (LilyPond-command (LilyPond-command-query (LilyPond-master-file)) + 'LilyPond-master-file)) + +(defun LilyPond-command-lilypond () + "Run lilypond for the current document." + (interactive) + (LilyPond-command (LilyPond-command-menu "LilyPond") 'LilyPond-master-file) +) + +(defun LilyPond-command-formatdvi () + "Format the dvi output of the current document." + (interactive) + (LilyPond-command (LilyPond-command-menu "2Dvi") 'LilyPond-master-file) +) + +(defun LilyPond-command-formatps () + "Format the ps output of the current document." + (interactive) + (LilyPond-command (LilyPond-command-menu "2PS") 'LilyPond-master-file) +) + +(defun LilyPond-command-formatmidi () + "Format the midi output of the current document." + (interactive) + (LilyPond-command (LilyPond-command-menu "2Midi") 'LilyPond-master-file) +) + +(defun LilyPond-command-smartview () + "View the dvi output of current document." + (interactive) + (LilyPond-command (LilyPond-command-menu "SmartView") 'LilyPond-master-file) +) + +(defun LilyPond-command-view () + "View the dvi output of current document." + (interactive) + (LilyPond-command (LilyPond-command-menu "View") 'LilyPond-master-file) +) + +(defun LilyPond-command-viewps () + "View the ps output of current document." + (interactive) + (LilyPond-command (LilyPond-command-menu "ViewPS") 'LilyPond-master-file) +) + +;;; Refer to syntax-table (in lilypond-font-lock.el) for comment characters. +(defun LilyPond-un-comment-region (start end level) + "Remove up to LEVEL comment characters from each line in the region." + (interactive "*r\np") + (comment-region start end (- level))) + +;; FIXME, this is broken +(defun LilyPond-region-file (begin end) + (let ( + ;; (dir "/tmp/") + ;; urg + (dir "./") + (base LilyPond-region-file-prefix) + ;; Hmm + (ext (if (string-match "^[\\]score" (buffer-substring begin end)) + ".ly" + (if (< 50 (abs (- begin end))) + ".fly" + ".sly")))) + (concat dir base ext))) + +(defun LilyPond-command-region (begin end) + "Run LilyPond on the current region." (interactive "r") + (write-region begin end (LilyPond-region-file begin end) nil 'nomsg) + (LilyPond-command (LilyPond-command-query + (LilyPond-region-file begin end)) + '(lambda () (LilyPond-region-file begin end)))) - (let ((dir default-directory) - (base "emacs-lily")) +(defun LilyPond-command-buffer () + "Run LilyPond on buffer." + (interactive) + (LilyPond-command-region (point-min) (point-max))) - ;; we don't really need this... - (let ((tex (concat dir base ".tex")) - (dvi (concat dir base ".dvi"))) - (if (file-exists-p tex) (delete-file tex)) - (if (file-exists-p dvi) (delete-file dvi))) - - (lily-eval-region start end) - (set-buffer "*lilypond*") - - ;;(setq default-directory dir) - (while (lily-running) - (continue-process (get-process "lilypond"))) - (sit-for 0) ; Force redisplay +(defun LilyPond-command-expand (string file) + (let ((case-fold-search nil)) + (if (string-match "%" string) + (let* ((b (match-beginning 0)) + (e (+ b 2)) + (l (split-file-name file)) + (dir (car l)) + (base (cadr l))) + (LilyPond-command-expand + (concat (substring string 0 b) + dir + base + (let ((entry (assoc (substring string b e) + LilyPond-expand-alist))) + (if entry (cdr entry) "")) + (substring string e)) + file)) + string))) + +(defun LilyPond-shell-process (name buffer command) + (let ((old (current-buffer))) + (switch-to-buffer-other-window buffer) + ;; If we empty the buffer don't see messages scroll by. + ;; (erase-buffer) - (if (= 0 (process-exit-status (get-process "lilypond"))) - (progn - (if (= 0 (lily-tex-file base)) - (lily-xdvi-file base)))))) + (start-process-shell-command name buffer command) + (switch-to-buffer-other-window old))) + -;;;###autoload -(defun lily-kill-job () - "Kill the currently running LilyPond job." - (interactive) - (quit-process (get-process "lilypond") t)) +(defun LilyPond-command (name file) + "Run command NAME on the file you get by calling FILE. + +FILE is a function return a file name. It has one optional argument, +the extension to use on the file. + +Use the information in LilyPond-command-alist to determine how to run the +command." + + (let ((entry (assoc name LilyPond-command-alist))) + (if entry + (let ((command (LilyPond-command-expand (cadr entry) + (apply file nil))) + (jobs nil) + (job-string "no jobs")) + (if (member name (list "View" "ViewPS")) + ;; is USR1 a right signal for viewps? + (let ((buffer-xdvi (get-buffer-create (concat "*" name "*")))) + (if LilyPond-kick-xdvi + (let ((process-xdvi (get-buffer-process buffer-xdvi))) + (if process-xdvi + (signal-process (process-id process-xdvi) 'SIGUSR1) + (LilyPond-shell-process name buffer-xdvi command))) + (LilyPond-shell-process name buffer-xdvi command))) + (progn + (if (string-equal name "Midi") + (progn + (setq command (concat LilyPond-midi-command " " (LilyPond-string-current-midi))) + (if (LilyPond-kill-midi) + (setq job-string nil)))) ; either stop or start playing + (if (string-equal name "MidiAll") + (progn + (setq command (concat LilyPond-all-midi-command " " (LilyPond-string-all-midi))) + (LilyPond-kill-midi))) ; stop and start playing + (if (and (member name (list "Midi" "MidiAll")) job-string) + (if (file-newer-than-file-p + (LilyPond-master-file) + (concat (substring (LilyPond-master-file) 0 -3) ".midi")) + (if (y-or-n-p "Midi older than source. Reformat midi?") + (progn + (LilyPond-command-formatmidi) + (while (LilyPond-running) + (message "Starts playing midi once it is built.") + (sit-for 0 100)))))) + (if (member name (list "LilyPond" "TeX" "2Midi" "2PS" "2Dvi" + "Book" "LaTeX")) + (if (setq jobs (LilyPond-running)) + (progn + (setq job-string "Process") ; could also suggest compiling after process has ended + (while jobs + (setq job-string (concat job-string " \"" (pop jobs) "\""))) + (setq job-string (concat job-string " is already running; kill it to proceed ")) + (if (y-or-n-p job-string) + (progn + (setq job-string "no jobs") + (LilyPond-kill-jobs) + (while (LilyPond-running) + (sit-for 0 100))) + (setq job-string nil))))) + + (setq LilyPond-command-default name) + (if (string-equal job-string "no jobs") + (LilyPond-compile-file command name)))))))) + +;; XEmacs stuff +;; Sadly we need this for a macro in Emacs 19. +(eval-when-compile + ;; Imenu isn't used in XEmacs, so just ignore load errors. + (condition-case () + (require 'imenu) + (error nil))) -;; hmm -;; (kill-process (get-process "xdvi") t) -(defvar lily-mode-map () - "Keymap used in `lilypond-mode' buffers.") +;;; Keymap + +(defvar LilyPond-mode-map () + "Keymap used in `LilyPond-mode' buffers.") ;; Note: if you make changes to the map, you must do -;; M-x set-variable lily-mode-map nil +;; M-x set-variable LilyPond-mode-map nil ;; M-x eval-buffer -;; M-x lilypond-mode +;; M-x LilyPond-mode ;; to let the changest take effect -(if lily-mode-map + +(if LilyPond-mode-map () - (setq lily-mode-map (make-sparse-keymap)) - (define-key lily-mode-map [f9] 'lily-eval-buffer) - (define-key lily-mode-map [f10] 'lily-xdvi-buffer) - (define-key lily-mode-map [S-f9] 'lily-eval-region) - (define-key lily-mode-map [S-f10] 'lily-xdvi-region) - ) + (setq LilyPond-mode-map (make-sparse-keymap)) + ;; Put keys to Lilypond-command-alist and fetch them from there somehow. + (define-key LilyPond-mode-map "\C-c\C-l" 'LilyPond-command-lilypond) + (define-key LilyPond-mode-map "\C-c\C-r" 'LilyPond-command-region) + (define-key LilyPond-mode-map "\C-c\C-b" 'LilyPond-command-buffer) + (define-key LilyPond-mode-map "\C-c\C-k" 'LilyPond-kill-jobs) + (define-key LilyPond-mode-map "\C-c\C-c" 'LilyPond-command-master) + (define-key LilyPond-mode-map "\C-cm" 'LilyPond-command-formatmidi) + (define-key LilyPond-mode-map "\C-c\C-d" 'LilyPond-command-formatdvi) + (define-key LilyPond-mode-map "\C-c\C-f" 'LilyPond-command-formatps) + (define-key LilyPond-mode-map "\C-c\C-s" 'LilyPond-command-smartview) + (define-key LilyPond-mode-map "\C-c\C-v" 'LilyPond-command-view) + (define-key LilyPond-mode-map "\C-c\C-p" 'LilyPond-command-viewps) + (define-key LilyPond-mode-map [(control c) return] 'LilyPond-command-current-midi) + (define-key LilyPond-mode-map [(control c) (control return)] 'LilyPond-command-all-midi) + (define-key LilyPond-mode-map "\C-x\C-s" 'LilyPond-save-buffer) + (define-key LilyPond-mode-map "\C-cf" 'font-lock-fontify-buffer) + (define-key LilyPond-mode-map "\C-ci" 'LilyPond-quick-note-insert) + (define-key LilyPond-mode-map "\C-cn" 'LilyPond-insert-tag-notes) + (define-key LilyPond-mode-map "\C-cs" 'LilyPond-insert-tag-score) + (define-key LilyPond-mode-map "\C-c:" 'LilyPond-un-comment-region) + (define-key LilyPond-mode-map "\C-c;" 'comment-region) + (define-key LilyPond-mode-map ")" 'LilyPond-electric-close-paren) + (define-key LilyPond-mode-map ">" 'LilyPond-electric-close-paren) + (define-key LilyPond-mode-map "}" 'LilyPond-electric-close-paren) + (define-key LilyPond-mode-map [iso-lefttab] 'LilyPond-autocompletion) ; Emacs + (define-key LilyPond-mode-map [iso-left-tab] 'LilyPond-autocompletion) ; XEmacs + (define-key LilyPond-mode-map "\C-c\t" 'LilyPond-info-index-search) + ) + +;;; Menu Support -(defun lilypond-mode () - "Major mode for editing Mudela files." +(defun LilyPond-quick-note-insert() + "Insert notes with fewer key strokes by using a simple keyboard piano." + (interactive) + (setq dutch-notes + '(("k" "a") ("l" "b") ("a" "c") ("s" "d") + ("d" "e") ("f" "f") ("j" "g") ("r" "r"))) + (setq dutch-note-ends '("eses" "es" "" "is" "isis")) + (setq dutch-note-replacements '("" "")) + (setq finnish-note-replacements + '(("eeses" "eses") ("ees" "es") ("aeses" "asas") ("aes" "as") ("b" "h") + ("beses" "heses") ("bes" "b") ("bis" "his") ("bisis" "hisis"))) + ; add more translations of the note names + (setq spanish-note-replacements + '(("c" "do") ("d" "re") ("e" "mi") ("f" "fa") ("g" "sol") ("a" "la") ("b +" "si") + ("cis" "dos") ("cisis" "doss") ("ces" "dob") ("ceses" "dobb") + ("dis" "res") ("disis" "ress") ("des" "reb") ("deses" "rebb") + ("eis" "mis") ("eisis" "miss") ("ees" "mib") ("eeses" "mibb") + ("fis" "fas") ("fisis" "fass") ("fes" "fab") ("feses" "fabb") + ("gis" "sols") ("gisis" "solss") ("ges" "solb") ("geses" "solbb") + ("ais" "las") ("aisis" "lass") ("aes" "lab") ("aeses" "labb") + ("bis" "sis") ("bisis" "siss") ("bes" "sib") ("beses" "sibb"))) + (setq other-keys "()<>~}") + (setq accid 0) (setq octav 0) (setq durat "") (setq dots 0) + + (message "Press h for help.") (sit-for 0 750) + + (setq note-replacements dutch-note-replacements) + (setq xkey 0) (setq xinitpoint (point)) + (< xinitpoint (point)) + (while (not (= xkey 27)) ; esc to quit + (message (format " a[]s[]d f[]j[]k[]l r with %4s%-4s%3s%-4s ie ,' 12345678 . 0 (<~>)/}b\\b\\n Esc" + (nth (+ accid 2) dutch-note-ends) + (make-string (abs octav) (if (> octav 0) ?' ?,)) + durat + (if (string= durat "") "" (make-string dots ?.)))) + (setq xkey (read-char-exclusive)) + (setq x (char-to-string xkey)) + (setq note (cdr (assoc x dutch-notes))) + (cond + ((string= x "q") (progn (setq xkey 27))) ; quit + ((= xkey 13) (progn (insert "\n") (LilyPond-indent-line))) ; return + ((or (= xkey 127) (string= x "b")) ; backspace is a char only in Emacs + (progn (narrow-to-region xinitpoint (point)) + (backward-kill-word 1) + (widen))) + ((and (string< x "9") (string< "0" x)) + (progn (setq durat (int-to-string (expt 2 (- (string-to-int x) 1)))) + (setq dots 0))) + ((string= x " ") (insert " ")) + ((string= x "/") (progn (insert "\\times ") + (message "Insert a number for the denominator (\"x/\")") + (while (not (and (string< x "9") (string< "0" x))) + (setq x (char-to-string (read-char-exclusive)))) + (insert (format "%s/" x)) (setq x "/") + (message "Insert a number for the numerator (\"/y\")") + (while (not (and (string< x "9") (string< "0" x))) + (setq x (char-to-string (read-char-exclusive)))) + (insert (format "%s { " x)))) + ((string= x "0") (progn (setq accid 0) (setq octav 0) + (setq durat "") (setq dots 0))) + ((string= x "i") (setq accid (if (= accid 2) 0 (max (+ accid 1) 1)))) + ((string= x "e") (setq accid (if (= accid -2) 0 (min (+ accid -1) -1)))) + ((string= x "'") (setq octav (if (= octav 4) 0 (max (+ octav 1) 1)))) + ((string= x ",") (setq octav (if (= octav -4) 0 (min (+ octav -1) -1)))) + ((string= x ".") (setq dots (if (= dots 4) 0 (+ dots 1)))) + ((not (null (member x (split-string other-keys "")))) + (insert (format "%s " x))) + ((not (null note)) + (progn + (setq note + (format "%s%s" (car note) (if (string= "r" (car note)) "" + (nth (+ accid 2) dutch-note-ends)))) + (setq notetwo (car (cdr (assoc note note-replacements)))) + (if (not (null notetwo)) (setq note notetwo)) + (insert + (format "%s%s%s%s " + note + (if (string= "r" note) "" + (make-string (abs octav) (if (> octav 0) ?' ?,))) + durat + (if (string= durat "") "" (make-string dots ?.)))) + (setq accid 0) (setq octav 0) (setq durat "") (setq dots 0))) + ((string= x "t") (progn (setq note-replacements dutch-note-replacements) + (message "Selected Dutch notes") + (sit-for 0 750))) + ((string= x "n") (progn (setq note-replacements finnish-note-replacements) + (message "Selected Finnish/Deutsch notes") + (sit-for 0 750))) + ; add more translations of the note names + ((string= x "p") (progn (setq note-replacements spanish-note-replacements) + (message "Selected Spanish notes") + (sit-for 0 750))) + ((string= x "h") + (progn (message "Insert notes with fewer key strokes. For example \"i,5.f\" produces \"fis,32. \".") (sit-for 5 0) + (message "Add also \"a ~ a\"-ties, \"a ( ) b\"-slurs and \"< a b >\"-chords.") (sit-for 5 0) + (message "There are Du(t)ch, Fin(n)ish/Deutsch (hit 'n') and S(p)anish note names.") (sit-for 5 0) + (message "(B)ackspace deletes last note, Ret starts a new indented line and Esc (q)uits.") (sit-for 5 0) + (message "Insert note triplets \"\\times 2/3 { a b } \" by typing \"/23ab}\".") (sit-for 5 0) + (message "This mode is experimental. Use normal mode to add further details.") (sit-for 5 0))))) + (message "Normal editing mode.")) + +(defun LilyPond-pre-word-search () + "Fetch the alphabetic characters and \\ in front of the cursor." + (interactive) + (let ((pre "") + (prelen 0) + (ch (char-before (- (point) 0)))) + (while (and ch (or (and (>= ch 65) (<= ch 90)) ; not bolp, A-Z + (and (>= ch 97) (<= ch 122)) ; a-z + (= ch 92))) ; \\ + (setq pre (concat (char-to-string ch) pre)) + (setq prelen (+ prelen 1)) + (setq ch (char-before (- (point) prelen)))) + pre)) + +(defun LilyPond-post-word-search () + "Fetch the alphabetic characters behind the cursor." + (interactive) + (let ((post "") + (postlen 0) + (ch (char-after (+ (point) 0)))) + (while (and ch (or (and (>= ch 65) (<= ch 90)) ; not eolp, A-Z + (and (>= ch 97) (<= ch 122)))) ; a-z + (setq post (concat post (char-to-string ch))) + (setq postlen (+ postlen 1)) + (setq ch (char-after (+ (point) postlen)))) + post)) + +(defun LilyPond-autocompletion () + "Show completions in mini-buffer for the given word." + (interactive) + (let ((pre (LilyPond-pre-word-search)) + (post (LilyPond-post-word-search)) + (compsstr "")) + ;; insert try-completion and show all-completions + (if (> (length pre) 0) + (progn + (setq trycomp (try-completion pre (LilyPond-add-dictionary-word ()))) + (if (char-or-string-p trycomp) + (if (string-equal (concat pre post) trycomp) + (goto-char (+ (point) (length post))) + (progn + (delete-region (point) (+ (point) (length post))) + (insert (substring trycomp (length pre) nil)))) + (progn + (delete-region (point) (+ (point) (length post))) + (font-lock-fontify-buffer))) ; only inserting fontifies + + (setq complist (all-completions pre (LilyPond-add-dictionary-word ()))) + (while (> (length complist) 0) + (setq compsstr (concat compsstr "\"" (car complist) "\" ")) + (setq complist (cdr complist))) + (message compsstr) + (sit-for 0 100))))) + +(defun LilyPond-info () + "Launch Info for lilypond." + (interactive) + (info "lilypond")) + +(defun LilyPond-music-glossary-info () + "Launch Info for music-glossary." + (interactive) + (info "music-glossary")) + +(defun LilyPond-internals-info () + "Launch Info for lilypond-internals." + (interactive) + (info "lilypond-internals")) + +(defun LilyPond-info-index-search () + "Inside Emacs, launch `info lilypond --index-search word-under-cursor'" + (interactive) + (let ((str (concat (LilyPond-pre-word-search) (LilyPond-post-word-search)))) + (if (and (> (length str) 0) + (string-equal (substring str 0 1) "\\")) + (setq str (substring str 1 nil))) + (LilyPond-info) + (Info-index str))) + +(defun LilyPond-insert-string (pre) + "Insert text to the buffer." + (interactive) + (insert pre) + (length pre)) + +(defun LilyPond-insert-between (text pre post) + "Insert text to the buffer if non-empty string is given." + (interactive) + (let ((str (read-string text))) + (if (string-equal str "") + 0 + (progn (setq pre_str_post (concat pre str post)) + (insert pre_str_post) + (length pre_str_post))))) + +(defun LilyPond-insert-tag-notes () + "LilyPond notes tag." + (interactive) + (setq begin (if (and transient-mark-mode mark-active) + (mark-marker) (point-marker))) + (setq end (point-marker)) + (goto-char begin) + (setq l1 (LilyPond-insert-string "\\notes ")) + (setq l2 (LilyPond-insert-between "Relative (e.g. c'): " "\\relative " " ")) + (if (eq l2 0) + (setq l2 (LilyPond-insert-between "Transpose (e.g. c c'): " "\\transpose " " "))) + (setq l3 (LilyPond-insert-string "{ ")) + (goto-char (+ end l1 l2 l3)) + (LilyPond-insert-string " }") + (goto-char (+ end l1 l2 l3))) + +(defun LilyPond-insert-tag-score () + "LilyPond score tag." + (interactive) + (setq begin (if (and transient-mark-mode mark-active) + (mark-marker) (point-marker))) + (setq end (point-marker)) + (goto-char begin) + (setq l1 (LilyPond-insert-string "\\score {\n ")) ; keep track of lengths + (goto-char (+ end l1)) + (LilyPond-insert-string "\n \\paper { }\n") + (setq l2 (if (y-or-n-p "Insert \"\\header\" field? ") + (+ (LilyPond-insert-string " \\header {") + (LilyPond-insert-between "Title: " "\n title = \"" "\"") + (LilyPond-insert-between "Subtitle: " "\n subtitle = \"" "\"") + (LilyPond-insert-between "Piece: " "\n piece = \"" "\"") + (LilyPond-insert-between "Opus: " "\n opus = \"" "\"") + (LilyPond-insert-string "\n }\n")) + 0)) + (setq l3 (if (y-or-n-p "Insert \"\\midi\" field? ") + (+ (LilyPond-insert-string " \\midi {") + (LilyPond-insert-between "Tempo: " " \\tempo (e.g. 4 = 60)" "") + (LilyPond-insert-string " }\n")) + 0)) + (setq l4 (LilyPond-insert-string "}\n")) + (goto-char (+ end l1))) + +(defun LilyPond-command-menu-entry (entry) + ;; Return LilyPond-command-alist ENTRY as a menu item. + (let ((name (car entry))) + (cond ((and (string-equal name LilyPond-command-Print) + LilyPond-printer-list) + (let ((command LilyPond-print-command) + (lookup 1)) + (append (list LilyPond-command-Print) + (mapcar 'LilyPond-command-menu-printer-entry + LilyPond-printer-list)))) + (t + (vector name (list 'LilyPond-command-menu name) t))))) + + +(easy-menu-define LilyPond-command-menu + LilyPond-mode-map + "Menu used in LilyPond mode." + (append '("Command") + '(("Command on" + [ "Master File" LilyPond-command-select-master + :keys "C-c C-c" :style radio + :selected (eq LilyPond-command-current 'LilyPond-command-master) ] + [ "Buffer" LilyPond-command-select-buffer + :keys "C-c C-b" :style radio + :selected (eq LilyPond-command-current 'LilyPond-command-buffer) ] + [ "Region" LilyPond-command-select-region + :keys "C-c C-r" :style radio + :selected (eq LilyPond-command-current 'LilyPond-command-region) ])) +;;; (let ((file 'LilyPond-command-on-current)) +;;; (mapcar 'LilyPond-command-menu-entry LilyPond-command-alist)) +;;; Some kind of mapping which includes :keys might be more elegant +;;; Put keys to Lilypond-command-alist and fetch them from there somehow. + '([ "LilyPond" LilyPond-command-lilypond t]) + '([ "TeX" (LilyPond-command (LilyPond-command-menu "TeX") 'LilyPond-master-file) ]) + '([ "2Dvi" LilyPond-command-formatdvi t]) + '([ "2PS" LilyPond-command-formatps t]) + '([ "2Midi" LilyPond-command-formatmidi t]) + '([ "Book" (LilyPond-command (LilyPond-command-menu "Book") 'LilyPond-master-file) ]) + '([ "LaTeX" (LilyPond-command (LilyPond-command-menu "LaTeX") 'LilyPond-master-file) ]) + '([ "Kill jobs" LilyPond-kill-jobs t]) + '("-----") + '([ "SmartView" LilyPond-command-smartview t]) + '([ "View" LilyPond-command-view t]) + '([ "ViewPS" LilyPond-command-viewps t]) + '("-----") + '([ "Midi (toggle)" LilyPond-command-current-midi t]) + '([ "Midi all" LilyPond-command-all-midi t]) + )) + +(easy-menu-define LilyPond-mode-menu + LilyPond-mode-map + "Menu used in LilyPond mode." + (append '("LilyPond") + '(("Insert" + [ "\\notes..." LilyPond-insert-tag-notes t] + [ "\\score..." LilyPond-insert-tag-score t] + ["Quick Notes" LilyPond-quick-note-insert t] + ["Autocompletion" LilyPond-autocompletion t] + )) + '(("Miscellaneous" + ["Uncomment Region" LilyPond-un-comment-region t] + ["Comment Region" comment-region t] + ["Refontify buffer" font-lock-fontify-buffer t] + )) + '(("Info" + ["LilyPond" LilyPond-info t] + ["LilyPond index-search" LilyPond-info-index-search t] + ["Music Glossary" LilyPond-music-glossary-info t] + ["LilyPond internals" LilyPond-internals-info t] + )) + )) + +(defconst LilyPond-imenu-generic-re "^\\([a-zA-Z]+\\) *=" + "Regexp matching Identifier definitions.") + +(defvar LilyPond-imenu-generic-expression + (list (list nil LilyPond-imenu-generic-re 1)) + "Expression for imenu") + +(defun LilyPond-command-select-master () + (interactive) + (message "Next command will be on the master file") + (setq LilyPond-command-current 'LilyPond-command-master)) + +(defun LilyPond-command-select-buffer () + (interactive) + (message "Next command will be on the buffer") + (setq LilyPond-command-current 'LilyPond-command-buffer)) + +(defun LilyPond-command-select-region () + (interactive) + (message "Next command will be on the region") + (setq LilyPond-command-current 'LilyPond-command-region)) + +(defun LilyPond-command-menu (name) + ;; Execute LilyPond-command-alist NAME from a menu. + (let ((LilyPond-command-force name)) + (funcall LilyPond-command-current))) + +(defun LilyPond-mode () + "Major mode for editing LilyPond music files. + +This mode knows about LilyPond keywords and line comments, not about +indentation or block comments. It features easy compilation, error +finding and viewing of a LilyPond source buffer or region. + +COMMANDS +\\{LilyPond-mode-map} +VARIABLES + +LilyPond-command-alist\t\talist from name to command +LilyPond-xdvi-command\t\tcommand to display dvi files -- bit superfluous" (interactive) ;; set up local variables (kill-all-local-variables) (make-local-variable 'font-lock-defaults) - (setq font-lock-defaults '(lily-font-lock-keywords)) + (setq font-lock-defaults '(LilyPond-font-lock-keywords)) + + ;; string and comments are fontified explicitly + (make-local-variable 'font-lock-keywords-only) + (setq font-lock-keywords-only t) + + ;; Multi-line font-locking needs Emacs 21.1 or newer. + ;; For older versions there is hotkey "C-c f". + (make-local-variable 'font-lock-multiline) + (setq font-lock-multiline t) (make-local-variable 'paragraph-separate) (setq paragraph-separate "^[ \t]*$") @@ -327,7 +1069,7 @@ (setq comment-start-skip "%{? *") (make-local-variable 'comment-end) - (setq comment-end "\n") + (setq comment-end "") (make-local-variable 'block-comment-start) (setq block-comment-start "%{") @@ -335,46 +1077,38 @@ (make-local-variable 'block-comment-end) (setq block-comment-end "%}") - ;; (make-local-variable 'comment-column) - ;; (setq comment-column 40) + (make-local-variable 'indent-line-function) + (setq indent-line-function 'LilyPond-indent-line) + + (set-syntax-table LilyPond-mode-syntax-table) + (setq major-mode 'LilyPond-mode) + (setq mode-name "LilyPond") + (setq local-abbrev-table LilyPond-mode-abbrev-table) + (use-local-map LilyPond-mode-map) + + ;; In Emacs blink-...-on-screen needs to be declared (, not in XEmacs). + (make-local-variable 'blink-matching-paren-on-screen) + (setq blink-matching-paren-on-screen t) (make-local-variable 'imenu-generic-expression) - (setq imenu-generic-expression lily-imenu-generic-expression) + (setq imenu-generic-expression LilyPond-imenu-generic-expression) + (imenu-add-to-menubar "Index") - (make-local-variable 'indent-line-function) - (setq indent-line-function 'indent-relative-maybe) - - ;; - (set-syntax-table lily-mode-syntax-table) - (setq major-mode 'lilypond-mode) - (setq mode-name "Mudela") - (setq local-abbrev-table lilypond-mode-abbrev-table) - (use-local-map lily-mode-map) - - ;; run the mode hook. lily-mode-hook use is deprecated - (run-hooks 'lilypond-mode-hook)) - - -(defun lily-keep-region-active () - ;; do whatever is necessary to keep the region active in XEmacs. - ;; Ignore byte-compiler warnings you might see. Also note that - ;; FSF's Emacs 19 does it differently and doesn't its policy doesn't - ;; require us to take explicit action. - (and (boundp 'zmacs-region-stays) - (setq zmacs-region-stays t))) - - -;;(defun lily-comment-region (beg end &optional arg) -;; "Like `comment-region' but uses double hash (`#') comment starter." -;; (interactive "r\nP") -;; (let ((comment-start lily-block-comment-prefix)) -;; (comment-region beg end arg))) - -(defun lily-version () - "Echo the current version of `lilypond-mode' in the minibuffer." - (interactive) - (message "Using `lilypond-mode' version %s" lily-version) - (lily-keep-region-active)) + ;; In XEmacs one needs to use 'easy-menu-add' (, not in Emacs). + (easy-menu-add LilyPond-mode-menu) + (easy-menu-add LilyPond-command-menu) + + ;; run the mode hook. LilyPond-mode-hook use is deprecated + (run-hooks 'LilyPond-mode-hook)) + +(defun LilyPond-version () + "Echo the current version of `LilyPond-mode' in the minibuffer." + (interactive) + (message "Using `LilyPond-mode' version %s" LilyPond-version)) + +(load-library "lilypond-font-lock") +(load-library "lilypond-indent") (provide 'lilypond-mode) ;;; lilypond-mode.el ends here +