;;; * Keyboard shortcuts (12th Sep 2001)
;;; * Inserting tags, inspired on sgml-mode (11th Oct 2001)
;;; * Autocompletion & Info (23rd Nov 2002)
-;;;
-;;; Changed 2002 Carlos Betancourt <carlos.betancourt@chello.be>
-;;; * Added spanish-note-replacements
;;; Inspired on auctex
(require 'easymenu)
(require 'compile)
-(defconst LilyPond-version "1.7.12"
+(defconst LilyPond-version "1.8.0"
"`LilyPond-mode' version number.")
(defconst LilyPond-help-address "bug-lilypond@gnu.org"
(defvar LilyPond-mode-hook nil
"*Hook called by `LilyPond-mode'.")
+(defvar LilyPond-region-file-prefix "emacs-lily"
+ "File prefix for commands on buffer or region.")
+
;; FIXME: find ``\score'' in buffers / make settable?
(defun LilyPond-master-file ()
;; duh
'(("\\([a-zA-Z]?:?[^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 2))
"Regexp used to match LilyPond errors. See `compilation-error-regexp-alist'.")
+(defvar LilyPond-imenu nil
+ "A flag to tell whether LilyPond-imenu is turned on.")
+(make-variable-buffer-local 'LilyPond-imenu)
+
(defcustom LilyPond-include-path ".:/tmp"
"* LilyPond include path."
:type 'string
(defun LilyPond-words-filename ()
"The file containing LilyPond \keywords \Identifiers and ReservedWords.
-Finds file lilypond-words from load-path."
+Finds file lilypond-words.el from load-path."
(let ((fn nil)
(lp load-path)
- (words-file "lilypond.words"))
+ (words-file "lilypond.words.el"))
(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 "Error (shown for 12 seconds; press a key to skip):\n\n File `lilypond.words' containing keywords to be autocompleted and fontified,\n was not found. Place it to your `load-path' (see `lilypond-init.el').\n")
- (sit-for 12 0 1)))
+ (progn (message "Warning: `lilypond.words.el' not found in `load-path'. See `lilypond-init.el'.")
+ (sit-for 5 0)))
fn))
(defun LilyPond-add-dictionary-word (x)
(LilyPond-add-dictionary-word (list copy)))
(kill-buffer b)))
-(defconst LilyPond-keywords
- (let ((wordlist ())
- (co (all-completions "" (LilyPond-add-dictionary-word ()))))
+(defvar LilyPond-insert-tag-current ""
+ "The last command selected from the LilyPond-Insert -menu.")
+
+(defconst LilyPond-menu-keywords
+ (let ((wordlist '())
+ (co (all-completions "" (LilyPond-add-dictionary-word ())))
+ (currword ""))
(progn
(while (> (length co) 0)
- (if (> (length (car co)) 1)
- (if (and (string-equal "\\" (substring (car co) 0 1))
- (string-equal (downcase (car co)) (car co)))
- (add-to-list 'wordlist (car co))))
- (setq co (cdr co)))
- (if (eq (length wordlist) 0)
- (setq wordlist '("\\score"))) ; add \keywords to lilypond.words
+ (setq currword (car co))
+ (if (string-equal "-" (car (setq co (cdr co))))
+ (progn
+ (add-to-list 'wordlist currword)
+ (while (and (> (length co) 0)
+ (not (string-equal "-" (car (setq co (cdr co))))))))))
+ (reverse wordlist)))
+ "Keywords inserted from LilyPond-Insert-menu.")
+
+(defconst LilyPond-keywords
+ (let ((wordlist '("\\score"))
+ (co (all-completions "" (LilyPond-add-dictionary-word ())))
+ (currword ""))
+ (progn
+ (while (> (length co) 0)
+ (setq currword (car co))
+ (if (> (length currword) 1)
+ (if (and (string-equal "\\" (substring currword 0 1))
+ (progn (string-match "[a-z-]+" currword)
+ (= (match-end 0) (length currword)))
+ (not (string-equal "\\longa" currword))
+ (not (string-equal "\\breve" currword))
+ (not (string-equal "\\maxima" currword))
+ (string-equal (downcase currword) currword))
+ (add-to-list 'wordlist currword)))
+ (if (string-equal "-" (car (setq co (cdr co))))
+ (while (and (> (length co) 0)
+ (not (string-equal "-" (car (setq co (cdr co)))))))))
wordlist))
"LilyPond \\keywords")
(defconst LilyPond-identifiers
- (let ((wordlist ())
+ (let ((wordlist '("\\voiceOne"))
(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
+ (setq currword (car co))
+ (if (> (length currword) 1)
+ (if (and (string-equal "\\" (substring currword 0 1))
+ (progn (string-match "[a-zA-Z-]+" currword)
+ (= (match-end 0) (length currword)))
+ (not (string-equal (downcase currword) currword)))
+ (add-to-list 'wordlist currword)))
+ (if (string-equal "-" (car (setq co (cdr co))))
+ (while (and (> (length co) 0)
+ (not (string-equal "-" (car (setq co (cdr co)))))))))
wordlist))
"LilyPond \\Identifiers")
-(defconst LilyPond-reserved-words
- (let ((wordlist ())
+(defconst LilyPond-Capitalized-Reserved-Words
+ (let ((wordlist '("Staff"))
+ (co (all-completions "" (LilyPond-add-dictionary-word ()))))
+ (progn
+ (while (> (length co) 0)
+ (setq currword (car co))
+ (if (> (length currword) 0)
+ (if (and (progn (string-match "[a-zA-Z_]+" currword)
+ (= (match-end 0) (length currword)))
+ (not (string-equal (downcase currword) currword)))
+ (add-to-list 'wordlist currword)))
+ (if (string-equal "-" (car (setq co (cdr co))))
+ (while (and (> (length co) 0)
+ (not (string-equal "-" (car (setq co (cdr co)))))))))
+ wordlist))
+ "LilyPond ReservedWords")
+
+(defconst LilyPond-non-capitalized-reserved-words
+ (let ((wordlist '("c"))
(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
+ (setq currword (car co))
+ (if (> (length currword) 0)
+ (if (and (progn (string-match "[a-z]+" currword)
+ (= (match-end 0) (length currword)))
+ (string-equal (downcase currword) currword))
+ (add-to-list 'wordlist currword)))
+ (if (string-equal "-" (car (setq co (cdr co))))
+ (while (and (> (length co) 0)
+ (not (string-equal "-" (car (setq co (cdr co)))))))))
wordlist))
"LilyPond ReservedWords")
(defun LilyPond-running ()
"Check the currently running LilyPond compiling jobs."
- (interactive)
(let ((process-names (list "lilypond" "tex" "2dvi" "2ps" "2midi"
"book" "latex"))
(running nil))
(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))
(defun LilyPond-compile-file (command name)
;; We maybe should know what we run here (Lily, ly2dvi, tex)
;; and adjust our error-matching regex ?
- (compile-internal command "No more errors" name ))
+ (compile-internal
+ (if (eq LilyPond-command-current 'LilyPond-command-master)
+ command
+ ;; use temporary directory for Commands on Buffer/Region
+ ;; hm.. the directory is set twice, first to default-dir
+ (concat "cd " (LilyPond-temp-directory) "; " command))
+ "No more errors" name))
;; do we still need this, now that we're using compile-internal?
(defun LilyPond-save-buffer ()
(defun count-midi-words ()
"Check number of midi-scores before the curser."
- (interactive)
- (count-rexp (point-min) (point-max) "\\\\midi"))
+ (if (eq LilyPond-command-current 'LilyPond-command-region)
+ (count-rexp (mark t) (point) "\\\\midi")
+ (count-rexp (point-min) (point-max) "\\\\midi")))
(defun count-midi-words-backwards ()
"Check number of midi-scores before the curser."
- (interactive)
- (count-rexp (point-min) (point) "\\\\midi"))
+ (if (eq LilyPond-command-current 'LilyPond-command-region)
+ (count-rexp (mark t) (point) "\\\\midi")
+ (count-rexp (point-min) (point) "\\\\midi")))
(defun LilyPond-string-current-midi ()
"Check the midi file of the following midi-score in the current document."
- (interactive)
- (let ((fnameprefix (substring (LilyPond-master-file) 0 -3)) ; suppose ".ly"
+ (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master)
+ (substring (LilyPond-master-file) 0 -3); suppose ".ly"
+ LilyPond-region-file-prefix))
(allcount (string-to-number (substring (count-midi-words) 0 -12)))
(count (string-to-number (substring (count-midi-words-backwards) 0 -12))))
(concat fnameprefix
(defun LilyPond-string-all-midi ()
"Return the midi files of the current document in ascending order."
- (interactive)
- (let ((fnameprefix (substring (LilyPond-master-file) 0 -3))
+ (let ((fnameprefix (if (eq LilyPond-command-current 'LilyPond-command-master)
+ (substring (LilyPond-master-file) 0 -3); suppose ".ly"
+ LilyPond-region-file-prefix))
(allcount (string-to-number (substring (count-midi-words) 0 -12))))
(concat (if (> allcount 0) ; at least one midi-score
(concat fnameprefix ".midi "))
;; Should expand this to include possible keyboard shortcuts which
;; could then be mapped to define-key and menu.
`(
- ("LilyPond" . ("lilypond %s" . "LaTeX"))
+ ("Raw LilyPond" . ("lilypond-bin %s" . "LaTeX"))
("TeX" . ("tex '\\nonstopmode\\input %t'" . "View"))
- ("2Dvi" . ("ly2dvi %s" . "View"))
- ("2PS" . ("ly2dvi -P %s" . "ViewPS"))
+ ("2Dvi" . ("lilypond %s" . "View"))
+ ("2PS" . ("lilypond -P %s" . "ViewPS"))
("2Midi" . ("lilypond -m %s" . "View"))
("Book" . ("lilypond-book %x" . "LaTeX"))
(string :tag "Next Key")))))
;; drop this?
-(defcustom LilyPond-file-extensions '(".ly" ".sly" ".fly")
- "*File extensions used by manually generated TeX files."
+(defcustom LilyPond-file-extension ".ly"
+ "*File extension used in LilyPond sources."
:group 'LilyPond
- :type '(repeat (string :format "%v")))
+ :type 'string)
(defcustom LilyPond-expand-alist
(defun LilyPond-command-query (name)
"Query the user for what LilyPond command to use."
- (let* ((default (cond ((if (string-equal name "emacs-lily")
+ (let* ((default (cond ((if (string-equal name LilyPond-region-file-prefix)
(LilyPond-check-files (concat name ".tex")
(list name)
- LilyPond-file-extensions)
+ (list LilyPond-file-extension))
(if (verify-visited-file-modtime (current-buffer))
(if (buffer-modified-p)
(if (y-or-n-p "Save buffer before next command? ")
(defun LilyPond-command-master ()
"Run command on the current document."
(interactive)
+ (LilyPond-command-select-master)
(LilyPond-command (LilyPond-command-query (LilyPond-master-file))
'LilyPond-master-file))
(LilyPond-command (LilyPond-command-menu "ViewPS") 'LilyPond-master-file)
)
-;; FIXME, does not find commend ender
-(defun LilyPond-un-comment-region (start end level)
- "Remove up to LEVEL comment characters from each line in the region."
- (interactive "*r\np")
- (comment-region start end (- level)))
-
;; FIXME, this is broken
(defun LilyPond-region-file (begin end)
(let (
- ;; (dir "/tmp/")
- ;; urg
- (dir "./")
- (base "emacs-lily")
- ;; Hmm
- (ext (if (string-match "^[\\]score" (buffer-substring begin end))
- ".ly"
- (if (< 50 (abs (- begin end)))
- ".fly"
- ".sly"))))
+ ;; (dir "./")
+ (dir (LilyPond-temp-directory))
+ (base LilyPond-region-file-prefix)
+ (ext LilyPond-file-extension))
(concat dir base ext)))
+;;; Commands on Region work if there is an appropriate '\score'.
(defun LilyPond-command-region (begin end)
"Run LilyPond on the current region."
(interactive "r")
+ (if (or (> begin (point-min)) (< end (point-max)))
+ (LilyPond-command-select-region))
(write-region begin end (LilyPond-region-file begin end) nil 'nomsg)
(LilyPond-command (LilyPond-command-query
(LilyPond-region-file begin end))
- '(lambda () (LilyPond-region-file begin end))))
+ '(lambda () (LilyPond-region-file begin end)))
+ ;; Region may deactivate even if buffer was intact, reactivate?
+ ;; Currently, also deactived regions are used.
+ )
(defun LilyPond-command-buffer ()
"Run LilyPond on buffer."
(interactive)
+ (LilyPond-command-select-buffer)
(LilyPond-command-region (point-min) (point-max)))
(defun LilyPond-command-expand (string file)
(if (string-equal job-string "no jobs")
(LilyPond-compile-file command name))))))))
-;; XEmacs stuff
-;; Sadly we need this for a macro in Emacs 19.
-(eval-when-compile
- ;; Imenu isn't used in XEmacs, so just ignore load errors.
- (condition-case ()
- (require 'imenu)
- (error nil)))
+(defun LilyPond-mark-active ()
+ "Check if there is an active mark."
+ (and transient-mark-mode
+ (if (string-match "XEmacs\\|Lucid" emacs-version) (mark) mark-active)))
+(defun LilyPond-temp-directory ()
+ "Temporary file directory for Commands on Region."
+ (interactive)
+ (if (string-match "XEmacs\\|Lucid" emacs-version)
+ (concat (temp-directory) "/")
+ temporary-file-directory))
;;; Keymap
(if LilyPond-mode-map
()
(setq LilyPond-mode-map (make-sparse-keymap))
- ;; Put keys to Lilypond-command-alist and fetch them from there somehow.
+ ;; Put keys to LilyPond-command-alist and fetch them from there somehow.
(define-key LilyPond-mode-map "\C-c\C-l" 'LilyPond-command-lilypond)
(define-key LilyPond-mode-map "\C-c\C-r" 'LilyPond-command-region)
(define-key LilyPond-mode-map "\C-c\C-b" 'LilyPond-command-buffer)
(define-key LilyPond-mode-map [(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 "\C-ci" 'LilyPond-insert-tag-current)
+ ;; the following will should be overriden by Lilypond Quick Insert Mode
+ (define-key LilyPond-mode-map "\C-cq" 'LilyPond-quick-insert-mode)
+ (define-key LilyPond-mode-map "\C-c;" 'LilyPond-comment-region)
(define-key LilyPond-mode-map ")" 'LilyPond-electric-close-paren)
(define-key LilyPond-mode-map ">" 'LilyPond-electric-close-paren)
(define-key LilyPond-mode-map "}" 'LilyPond-electric-close-paren)
- (define-key LilyPond-mode-map [(shift iso-lefttab)] 'LilyPond-autocompletion)
+ (define-key LilyPond-mode-map "]" 'LilyPond-electric-close-paren)
+ (if (string-match "XEmacs\\|Lucid" emacs-version)
+ (define-key LilyPond-mode-map [iso-left-tab] 'LilyPond-autocompletion)
+ (define-key LilyPond-mode-map [iso-lefttab] 'LilyPond-autocompletion))
(define-key LilyPond-mode-map "\C-c\t" 'LilyPond-info-index-search)
)
;;; Menu Support
-(defun LilyPond-quick-note-insert()
+;;; This mode was originally LilyPond-quick-note-insert by Heikki Junes.
+;;; The original version has been junked since CVS-1.97,
+;;; in order to merge the efforts done by Nicolas Sceaux.
+;;; LilyPond Quick Insert Mode is a major mode, toggled by C-c q.
+(defun LilyPond-quick-insert-mode ()
"Insert notes with fewer key strokes by using a simple keyboard piano."
(interactive)
- (setq dutch-notes
- '(("k" "a") ("l" "b") ("a" "c") ("s" "d")
- ("d" "e") ("f" "f") ("j" "g") ("r" "r")))
- (setq dutch-note-ends '("eses" "es" "" "is" "isis"))
- (setq dutch-note-replacements '("" ""))
- (setq finnish-note-replacements
- '(("eeses" "eses") ("ees" "es") ("aeses" "asas") ("aes" "as") ("b" "h")
- ("beses" "heses") ("bes" "b") ("bis" "his") ("bisis" "hisis")))
- ; add more translations of the note names
- (setq spanish-note-replacements
- '(("c" "do") ("d" "re") ("e" "mi") ("f" "fa") ("g" "sol") ("a" "la") ("b" "si")
- ("cis" "dos") ("cisis" "doss") ("ces" "dob") ("ceses" "dobb")
- ("dis" "res") ("disis" "ress") ("des" "reb") ("deses" "rebb")
- ("eis" "mis") ("eisis" "miss") ("ees" "mib") ("eeses" "mibb")
- ("fis" "fas") ("fisis" "fass") ("fes" "fab") ("feses" "fabb")
- ("gis" "sols") ("gisis" "solss") ("ges" "solb") ("geses" "solbb")
- ("ais" "las") ("aisis" "lass") ("aes" "lab") ("aeses" "labb")
- ("bis" "sis") ("bisis" "siss") ("bes" "sib") ("beses" "sibb")))
- (setq other-keys "()<>~}")
- (setq accid 0) (setq octav 0) (setq durat "") (setq dots 0)
-
- (message "Press h for help.") (sit-for 0 750 1)
-
- (setq note-replacements dutch-note-replacements)
- (while (not (= 27 ; esc to quit
- (setq x (read-char-exclusive
- (format " | a[_]s[_]d | f[_]j[_]k[_]l | r with ie ,' 12345678 . 0 (<~>)/}\\b\\n Esc \n | c | d | e | f | g | a | %s | r with %s%s%s%s"
- (if (string= (car(cdr(assoc "b" note-replacements))) "h")
- "h" "b")
- (nth (+ accid 2) dutch-note-ends)
- (make-string (abs octav) (if (> octav 0) ?' ?,))
- durat
- (if (string= durat "") "" (make-string dots ?.)))))))
- ;; (insert (number-to-string x)) ; test numbers for characters
- (setq note (cdr (assoc (char-to-string x) dutch-notes)))
- (cond
- ((= x 127) (backward-kill-word 1)) ; backspace
- ((= x 13) (progn (insert "\n") (LilyPond-indent-line)))) ; return
- (setq x (char-to-string x))
- (cond
- ((and (string< x "9") (string< "0" x))
- (progn (setq durat (int-to-string (expt 2 (- (string-to-int x) 1))))
- (setq dots 0)))
- ((string= x " ") (insert " "))
- ((string= x "/") (progn (insert "\\times ")
- (while (not (and (string< x "9") (string< "0" x)))
- (setq x (char-to-string (read-char-exclusive "Insert a number for the denominator (\"x/\")"))))
- (insert (format "%s/" x)) (setq x "/")
- (while (not (and (string< x "9") (string< "0" x)))
- (setq x (char-to-string (read-char-exclusive "Insert a number for the numerator (\"/y\")"))))
- (insert (format "%s { " x))))
- ((string= x "0") (progn (setq accid 0) (setq octav 0)
- (setq durat "") (setq dots 0)))
- ((string= x "i") (setq accid (if (= accid 2) 0 (max (+ accid 1) 1))))
- ((string= x "e") (setq accid (if (= accid -2) 0 (min (+ accid -1) -1))))
- ((string= x "'") (setq octav (if (= octav 4) 0 (max (+ octav 1) 1))))
- ((string= x ",") (setq octav (if (= octav -4) 0 (min (+ octav -1) -1))))
- ((string= x ".") (setq dots (if (= dots 4) 0 (+ dots 1))))
- ((not (null (member x (split-string other-keys ""))))
- (insert (format "%s " x)))
- ((not (null note))
- (progn
- (setq note
- (format "%s%s" (car note) (if (string= "r" (car note)) ""
- (nth (+ accid 2) dutch-note-ends))))
- (setq notetwo (car (cdr (assoc note note-replacements))))
- (if (not (null notetwo)) (setq note notetwo))
- (insert
- (format "%s%s%s%s "
- note
- (if (string= "r" note) ""
- (make-string (abs octav) (if (> octav 0) ?' ?,)))
- durat
- (if (string= durat "") "" (make-string dots ?.))))
- (setq accid 0) (setq octav 0) (setq durat "") (setq dots 0)))
- ((string= x "t") (progn (setq note-replacements dutch-note-replacements)
- (message "Selected Dutch notes")
- (sit-for 0 750 1))) ; t
- ((string= x "n") (progn (setq note-replacements finnish-note-replacements)
- (message "Selected Finnish/Deutsch notes")
- (sit-for 0 750 1))) ; n
- ; add more translations of the note names
- ((string= x "p") (progn (setq note-replacements spanish-note-replacements)
- (message "Selected Spanish notes")
- (sit-for 0 750 1))) ; p
- ((string= x "h")
- (progn (message "Insert notes with fewer key strokes. For example \"i,5.f\" produces \"fis,32. \".") (sit-for 5 0 1)
- (message "Add also \"a ~ a\"-ties, \"a ( ) b\"-slurs and \"< a b >\"-chords.") (sit-for 5 0 1)
- (message "Note names are in Du(t)ch by default. Hit 'n' for Fin(n)ish/Deutsch note names. Hit 'p' for S(p)anish note names") (sit-for 5 0 1)
- (message "Backspace deletes last note, return starts a new indented line and Esc quits.") (sit-for 5 0 1)
- (message "Insert note triplets \"\\times 2/3 { a b } \" by typing \"/23ab}\".") (sit-for 5 0 1)
- (message "Remember to add all other details as well.") (sit-for 5 0 1)))
- )))
+ (progn
+ (message "Invoke (C-c q) from keyboard. If you still see this message,") (sit-for 5 0)
+ (message "then you have not installed LilyPond Quick Insert Mode (lyqi).") (sit-for 5 0)
+ (message "Download lyqi from http://nicolas.sceaux.free.fr/lilypond/lyqi.html,") (sit-for 5 0)
+ (message "see installation instructions from lyqi's README -file.") (sit-for 5 0)
+ (message "You need also eieio (Enhanced Integration of Emacs Interpreted Objects).") (sit-for 5 0)
+ (message "Download eieio from http://cedet.sourceforge.net/eieio.shtml,") (sit-for 5 0)
+ (message "see installation instructions from eieio's INSTALL -file.") (sit-for 5 0)
+ (message "")
+ ))
(defun LilyPond-pre-word-search ()
"Fetch the alphabetic characters and \\ in front of the cursor."
- (interactive)
(let ((pre "")
(prelen 0)
(ch (char-before (- (point) 0))))
(defun LilyPond-post-word-search ()
"Fetch the alphabetic characters behind the cursor."
- (interactive)
(let ((post "")
(postlen 0)
(ch (char-after (+ (point) 0))))
(setq compsstr (concat compsstr "\"" (car complist) "\" "))
(setq complist (cdr complist)))
(message compsstr)
- (sit-for 0 100 1)))))
+ (sit-for 0 100)))))
(defun LilyPond-info ()
"Launch Info for lilypond."
(info "lilypond-internals"))
(defun LilyPond-info-index-search ()
- "Inside Emacs, launch `info lilypond --index-search word-under-cursor'"
+ "In `*info*'-buffer, launch `info lilypond --index-search word-under-cursor'"
(interactive)
(let ((str (concat (LilyPond-pre-word-search) (LilyPond-post-word-search))))
(if (and (> (length str) 0)
(LilyPond-info)
(Info-index str)))
-(defun LilyPond-insert-string (pre)
- "Insert text to the buffer."
+(defun LilyPond-insert-tag-current (&optional word)
+ "Set the current tag to be inserted."
(interactive)
- (insert pre)
- (length pre))
-
-(defun LilyPond-insert-between (text pre post)
- "Insert text to the buffer if non-empty string is given."
+ (if word
+ (setq LilyPond-insert-tag-current word))
+ (if (memq LilyPond-insert-tag-current LilyPond-menu-keywords)
+ (LilyPond-insert-tag)
+ (message "No tag was selected from LilyPond->Insert tag-menu.")))
+
+(defun LilyPond-insert-tag ()
+ "Insert syntax for given tag. The definitions are in LilyPond-words-filename."
(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)))
+ (setq b (find-file-noselect (LilyPond-words-filename) t t))
+ (let ((word LilyPond-insert-tag-current)
+ (found nil)
+ (p nil)
+ (query nil)
+ (m (set-marker (make-marker) 1 (get-buffer b)))
+ (distance (if (LilyPond-mark-active)
+ (abs (- (mark-marker) (point-marker))) 0))
+ )
+ ;; find the place first
+ (if (LilyPond-mark-active)
+ (goto-char (min (mark-marker) (point-marker))))
+ (while (and (not found) (> (buffer-size b) (marker-position m)))
+ (setq copy (car (copy-alist (list (eval (symbol-name (read m)))))))
+ (if (string-equal word copy) (setq found t)))
+ (if found (insert word))
+ (if (> (buffer-size b) (marker-position m))
+ (setq copy (car (copy-alist (list (eval (symbol-name (read m))))))))
+ (if (not (string-equal "-" copy))
+ (setq found nil))
+ (while (and found (> (buffer-size b) (marker-position m)))
+ ;; find next symbol
+ (setq copy (car (copy-alist (list (eval (symbol-name (read m)))))))
+ ;; check whether it is the word, or the word has been found
+ (cond
+ ((string-equal "-" copy) (setq found nil))
+ ((string-equal "%" copy) (insert " " (read-string "Give Arguments: ")))
+ ((string-equal "_" copy)
+ (progn
+ (setq p (point))
+ (goto-char (+ p distance))))
+ ((string-equal "\?" copy) (setq query t))
+ ((string-equal "\!" copy) (setq query nil))
+ ((string-equal "\\n" copy)
+ (if (not query)
+ (progn (LilyPond-indent-line) (insert "\n") (LilyPond-indent-line))))
+ ((string-equal "{" copy)
+ (if (not query)
+ (progn (insert " { "))))
+ ((string-equal "}" copy)
+ (if (not query)
+ (progn (insert " } ") (setq query nil) )))
+ ((not query)
+ (insert copy))
+ (query
+ (if (y-or-n-p (concat "Proceed with `" copy "'? "))
+ (progn (insert copy) (setq query nil))))
+ ))
+ (if p (goto-char p))
+ (kill-buffer b))
+)
(defun LilyPond-command-menu-entry (entry)
;; Return LilyPond-command-alist ENTRY as a menu item.
;;; (let ((file 'LilyPond-command-on-current))
;;; (mapcar 'LilyPond-command-menu-entry LilyPond-command-alist))
;;; Some kind of mapping which includes :keys might be more elegant
-;;; Put keys to Lilypond-command-alist and fetch them from there somehow.
+;;; Put keys to LilyPond-command-alist and fetch them from there somehow.
'([ "LilyPond" LilyPond-command-lilypond t])
'([ "TeX" (LilyPond-command (LilyPond-command-menu "TeX") 'LilyPond-master-file) ])
'([ "2Dvi" LilyPond-command-formatdvi t])
'([ "Midi all" LilyPond-command-all-midi t])
))
+(defun LilyPond-menu-keywords-item (arg)
+ "Make vector for LilyPond-mode-keywords."
+ (vector arg (list 'LilyPond-insert-tag-current arg) :style 'radio :selected (list 'eq 'LilyPond-insert-tag-current arg)))
+
+(defun LilyPond-menu-keywords ()
+ "Make Insert Tag menu.
+
+The Insert Tag -menu is splitted into parts if it is long enough."
+
+ (let ((li (mapcar 'LilyPond-menu-keywords-item LilyPond-menu-keywords))
+ (w (round (sqrt (length LilyPond-menu-keywords))))
+ (splitted '())
+ (imin 0) imax lw rw)
+ (while (< imin (length LilyPond-menu-keywords))
+ (setq imax (- (min (+ imin w) (length LilyPond-menu-keywords)) 1))
+ (setq lw (nth imin LilyPond-menu-keywords))
+ (setq rw (nth imax LilyPond-menu-keywords))
+ (add-to-list 'splitted
+ (let ((l (list (concat (substring lw 0 (min 7 (length lw)))
+ " ... "
+ (substring rw 0 (min 7 (length rw)))))))
+ (while (<= imin imax)
+ (add-to-list 'l (nth imin li))
+ (setq imin (1+ imin)))
+ (reverse l))))
+ (if (> (length LilyPond-menu-keywords) 12) (reverse splitted) li)))
+
+;;; LilyPond-mode-menu should not be interactive, via "M-x LilyPond-<Tab>"
(easy-menu-define LilyPond-mode-menu
LilyPond-mode-map
"Menu used in LilyPond mode."
(append '("LilyPond")
- '(("Insert"
- [ "\\notes..." LilyPond-insert-tag-notes t]
- [ "\\score..." LilyPond-insert-tag-score t]
- ["Quick Notes" LilyPond-quick-note-insert t]
- ["Autocompletion" LilyPond-autocompletion t]
- ))
+ '(["Add index menu" LilyPond-add-imenu-menu])
+ (list (cons "Insert tag"
+ (cons ["Previously selected" LilyPond-insert-tag-current t]
+ (cons "-----"
+ (LilyPond-menu-keywords)))))
'(("Miscellaneous"
- ["Uncomment Region" LilyPond-un-comment-region t]
- ["Comment Region" comment-region t]
+ ["Autocompletion" LilyPond-autocompletion t]
+ ["(Un)comment Region" LilyPond-comment-region t]
["Refontify buffer" font-lock-fontify-buffer t]
+ "-----"
+ ["Quick Insert Mode" LilyPond-quick-insert-mode :keys "C-c q"]
))
'(("Info"
["LilyPond" LilyPond-info t]
(defun LilyPond-command-menu (name)
;; Execute LilyPond-command-alist NAME from a menu.
(let ((LilyPond-command-force name))
- (funcall LilyPond-command-current)))
+ (if (eq LilyPond-command-current 'LilyPond-command-region)
+ (if (eq (mark t) nil)
+ (progn (message "The mark is not set now") (sit-for 0 500))
+ (progn (if (not (not (LilyPond-mark-active)))
+ (progn (message "Region is not active, using region between inactive mark and current point.") (sit-for 0 500)))
+ (LilyPond-command-region (mark t) (point))))
+ (funcall LilyPond-command-current))))
+
+(defun LilyPond-add-imenu-menu ()
+ (interactive)
+ "Add an imenu menu to the menubar."
+ (if (not LilyPond-imenu)
+ (progn
+ (imenu-add-to-menubar "Index")
+ (redraw-frame (selected-frame))
+ (setq LilyPond-imenu t))
+ (message "%s" "LilyPond-imenu already exists.")))
+(put 'LilyPond-add-imenu-menu 'menu-enable '(not LilyPond-imenu))
(defun LilyPond-mode ()
"Major mode for editing LilyPond music files.
(make-local-variable 'indent-line-function)
(setq indent-line-function 'LilyPond-indent-line)
- (set-syntax-table LilyPond-mode-syntax-table)
+ (LilyPond-mode-set-syntax-table '(?\< ?\> ?\{ ?\}))
(setq major-mode 'LilyPond-mode)
(setq mode-name "LilyPond")
(setq local-abbrev-table LilyPond-mode-abbrev-table)
(use-local-map LilyPond-mode-map)
- ;; In 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)
-
+ ;; In XEmacs imenu was synched up with: FSF 20.4
(make-local-variable 'imenu-generic-expression)
(setq imenu-generic-expression LilyPond-imenu-generic-expression)
- (imenu-add-to-menubar "Index")
+ ;; (imenu-add-to-menubar "Index") ; see LilyPond-add-imenu-menu
+
+ ;; In XEmacs one needs to use 'easy-menu-add'.
+ (if (string-match "XEmacs\\|Lucid" emacs-version)
+ (progn
+ (easy-menu-add LilyPond-mode-menu)
+ (easy-menu-add LilyPond-command-menu)))
+
+ ;; Use Command on Region even for inactive mark (region).
+ (if (string-match "XEmacs\\|Lucid" emacs-version)
+ (setq zmacs-regions nil)
+ (setq mark-even-if-inactive t))
+
+ ;; Context dependent syntax tables in LilyPond-mode
+ (make-local-hook 'post-command-hook) ; XEmacs requires
+ (add-hook 'post-command-hook 'LilyPond-mode-context-set-syntax-table nil t)
- ;; In XEmacs one needs to use 'easy-menu-add' (, not in Emacs).
- (easy-menu-add LilyPond-mode-menu)
- (easy-menu-add LilyPond-command-menu)
+ ;; Turn on paren-mode buffer-locally, i.e., in LilyPond-mode
+ (if (string-match "XEmacs\\|Lucid" emacs-version)
+ (progn
+ (make-local-variable 'paren-mode)
+ (paren-set-mode 'paren)
+ (make-local-variable 'blink-matching-paren)
+ (setq blink-matching-paren t)
+ )
+ (progn
+ (make-local-variable 'blink-matching-paren-on-screen)
+ (setq blink-matching-paren-on-screen t)
+ ))
;; run the mode hook. LilyPond-mode-hook use is deprecated
(run-hooks 'LilyPond-mode-hook))
projects / lilypond.git / blobdiff