;;;
;;; source file of the GNU LilyPond music typesetter
;;;
-;;; (c) 1999--2001 Jan Nieuwenhuizen <janneke@gnu.org>
+;;; (c) 1999--2003 Jan Nieuwenhuizen <janneke@gnu.org>
;;;
-;;; Changed 2001--2002 Heikki Junes <heikki.junes@hut.fi>
+;;; Changed 2001--2003 Heikki Junes <heikki.junes@hut.fi>
;;; * Add PS-compilation, PS-viewing and MIDI-play (29th Aug 2001)
;;; * Keyboard shortcuts (12th Sep 2001)
;;; * Inserting tags, inspired on sgml-mode (11th Oct 2001)
(require 'easymenu)
(require 'compile)
-(defconst LilyPond-version "1.7.9"
+(defconst LilyPond-version "1.7.19"
"`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
+ (buffer-file-name))
+
(defvar LilyPond-kick-xdvi nil
"If true, no simultaneous xdvi's are started, but reload signal is sent.")
(setq fn (concat (car lp) "/" words-file))
(if (not (file-readable-p fn))
(progn (setq fn nil) (setq lp (cdr lp)))))
+ (if (not fn)
+ (progn (message "Warning: `lilypond.words' not found in `load-path'. See `lilypond-init.el'.")
+ (sit-for 5 0)))
fn))
(defun LilyPond-add-dictionary-word (x)
- "Contains all words: keywords, identifiers, reserved words."
+ "Contains all words: \keywords \Identifiers and ReservedWords."
(nconc '(("" . 1)) x))
-; creates dictionary if empty
-(if (eq (length (LilyPond-add-dictionary-word ())) 1)
+;; creates dictionary if empty
+(if (and (eq (length (LilyPond-add-dictionary-word ())) 1)
+ (not (eq (LilyPond-words-filename) nil)))
(progn
- (setq fn (LilyPond-words-filename))
- (setq b (find-file-noselect fn t t))
+ (setq b (find-file-noselect (LilyPond-words-filename) t t))
(setq m (set-marker (make-marker) 1 (get-buffer b)))
(setq i 1)
(while (> (buffer-size b) (marker-position m))
(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")
(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")
(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")
found))
(defun LilyPond-running ()
- (let ((process (get-process "lilypond")))
- (and process
- (eq (process-status process) 'run))))
-
-(defun Midi-running ()
- (let ((process (get-process "midi")))
- (and process
- (eq (process-status process) 'run))))
-
-(defun LilyPond-kill-job ()
- "Kill the currently running LilyPond job."
+ "Check the currently running LilyPond compiling jobs."
+ (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."
+ (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)
- ;; What bout TeX, Xdvi?
- (quit-process (get-process "lilypond") t))
+ (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 ))
+ (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 ()
:group 'LilyPond
:type 'string)
-(defcustom LilyPond-midi-all-command "timidity -ig"
+(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)
+ (LilyPond-command (LilyPond-command-menu "Midi") 'LilyPond-master-file))
+
+(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")
+ (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."
+ (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."
+ (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."
+ (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."
+ (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" . "View"))
+ ("2PS" . ("ly2dvi -P %s" . "ViewPS"))
("2Midi" . ("lilypond -m %s" . "View"))
("Book" . ("lilypond-book %x" . "LaTeX"))
;; 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"))
- ("Midi" . (,(concat LilyPond-midi-command " %m") . "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.
(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? ")
answer
default))))
-
-;; FIXME: find ``\score'' in buffers / make settable?
-(defun LilyPond-master-file ()
- ;; duh
- (buffer-file-name))
-
(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 "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 "ViewPS") 'LilyPond-master-file)
)
-(defun LilyPond-command-midi ()
- "Play midi corresponding to the current document."
- (interactive)
- (LilyPond-command (LilyPond-command-menu "Midi") 'LilyPond-master-file)
-)
-
-(defun count-rexp (start end rexp)
- "Print number of found regular expressions in the region."
- (interactive "r")
- (save-excursion
- (save-restriction
- (narrow-to-region start end)
- (goto-char (point-min))
- (count-matches rexp))))
-
-(defun count-midi-words ()
- "Print number of scores before the curser."
- (interactive)
- (count-rexp (point-min) (point-max) "\\\\midi"))
-
-(defun count-midi-words-backwards ()
- "Print number of scores before the curser."
- (interactive)
- (count-rexp (point-min) (point) "\\\\midi"))
-
-(defun LilyPond-command-next-midi ()
- "Play next midi score of the current document."
- (interactive)
- (if (Midi-running)
- (quit-process (get-process "midi") t)
- (LilyPond-compile-file
- (let ((fname (LilyPond-master-file))
- (allcount (string-to-number (substring (count-midi-words) 0 -12)))
- (count (string-to-number (substring (count-midi-words-backwards) 0 -12))))
- (concat LilyPond-midi-command " "
- (substring fname 0 -3) ; suppose ".ly"
- (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"))
- "Midi")))
-
-(defun LilyPond-command-all-midi ()
- "Play next midi score of the current document."
- (interactive)
- (if (Midi-running)
- (quit-process (get-process "midi") t)
- (LilyPond-compile-file
- (let ((fname (LilyPond-master-file))
- (allcount (string-to-number (substring (count-midi-words) 0 -12))))
- (concat LilyPond-midi-all-command " "
- (if (> allcount 0) ; at least one midi-score
- (concat (substring fname 0 -3) ".midi "))
- (if (> allcount 1) ; more than one midi-score
- (concat (substring fname 0 -3) "-?.midi "))
- (if (> allcount 9) ; etc.
- (concat (substring fname 0 -3) "-??.midi"))
- (if (> allcount 99) ; not first score
- (concat (substring fname 0 -3) "-???.midi"))))
- "Midi")))
-
+;;; 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")
;; 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)
(let ((entry (assoc name LilyPond-command-alist)))
(if entry
(let ((command (LilyPond-command-expand (cadr entry)
- (apply file nil))))
- (if (string-equal name "View")
- (let ((buffer-xdvi (get-buffer-create "*view*")))
+ (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
(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)
- (LilyPond-compile-file command name)))))))
+ (if (string-equal job-string "no jobs")
+ (LilyPond-compile-file command name))))))))
-;; XEmacs stuff
-;; Sadly we need this for a macro in Emacs 19.
-(eval-when-compile
- ;; Imenu isn't used in XEmacs, so just ignore load errors.
- (condition-case ()
- (require 'imenu)
- (error nil)))
+(defun LilyPond-mark-active ()
+ "Check if there is an active mark."
+ (and transient-mark-mode
+ (if (string-match "XEmacs\\|Lucid" emacs-version) (mark) mark-active)))
+(defun LilyPond-temp-directory ()
+ "Temporary file directory for Commands on Region."
+ (interactive)
+ (if (string-match "XEmacs\\|Lucid" emacs-version)
+ (concat (temp-directory) "/")
+ temporary-file-directory))
;;; Keymap
(if LilyPond-mode-map
()
(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-job)
+ (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 "\C-c\C-m" 'LilyPond-command-next-midi)
+ (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 ")" '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 [S-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)
)
"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")))
+ '(("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
+ '(("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")
+ '(("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")
("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 other-keys "(<~>)}|")
(setq accid 0) (setq octav 0) (setq durat "") (setq dots 0)
- (message "Press h for help.") (sit-for 0 750 1)
+ (message "Press h for help.") (sit-for 0 750)
(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")
+ (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 /%sb\\b\\n Esc"
(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))
+ (make-string (abs octav) (if (> octav 0) ?' ?,))
+ durat
+ (if (string= durat "") "" (make-string dots ?.))
+ other-keys))
+ (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) ; backspace is recognized as a char only in Emacs
+ (string= x "b")) ; so, we need to define an another char for XEmacs
+ (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)))
+ (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)))
+ (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))))
(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)))
+ (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
+ (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 1))) ; n
- ; add more translations of the note names
+ (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 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)))
- )))
+ (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)))
+ (t (progn (message "Quick notes mode. Press Esc or q to quit.") (sit-for 0 500)))))
+ (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
+ (while (and ch (or (and (>= ch 65) (<= ch 90)) ; not bolp, A-Z
(and (>= ch 97) (<= ch 122)) ; a-z
- (= ch 92))) ; \\
+ (= ch 92))) ; \\
(setq pre (concat (char-to-string ch) pre))
(setq prelen (+ prelen 1))
(setq ch (char-before (- (point) prelen))))
(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
+ (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))
(let ((pre (LilyPond-pre-word-search))
(post (LilyPond-post-word-search))
(compsstr ""))
- ; insert try-completion and show all-completions
+ ;; insert try-completion and show all-completions
(if (> (length pre) 0)
(progn
(setq trycomp (try-completion pre (LilyPond-add-dictionary-word ())))
(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."
"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'"
+ "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)
(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
(defun LilyPond-insert-tag-notes ()
"LilyPond notes tag."
(interactive)
- (setq begin (if (and transient-mark-mode mark-active)
+ (setq begin (if (LilyPond-mark-active)
(mark-marker) (point-marker)))
(setq end (point-marker))
(goto-char begin)
(defun LilyPond-insert-tag-score ()
"LilyPond score tag."
(interactive)
- (setq begin (if (and transient-mark-mode mark-active)
+ (setq begin (if (LilyPond-mark-active)
(mark-marker) (point-marker)))
(setq end (point-marker))
(goto-char begin)
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-between "Tempo: (e.g. 4=60) " " \\tempo " "")
(LilyPond-insert-string " }\n"))
0))
(setq l4 (LilyPond-insert-string "}\n"))
[ "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))
+;;; (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 (LilyPond-command-menu "2Midi") 'LilyPond-master-file)])
+ '([ "2Midi" LilyPond-command-formatmidi t])
'([ "Book" (LilyPond-command (LilyPond-command-menu "Book") 'LilyPond-master-file) ])
'([ "LaTeX" (LilyPond-command (LilyPond-command-menu "LaTeX") 'LilyPond-master-file) ])
+ '([ "Kill jobs" LilyPond-kill-jobs t])
+ '("-----")
'([ "SmartView" LilyPond-command-smartview t])
'([ "View" LilyPond-command-view t])
'([ "ViewPS" LilyPond-command-viewps t])
- '([ "Midi (off)" LilyPond-command-next-midi t])
+ '("-----")
+ '([ "Midi (toggle)" LilyPond-command-current-midi t])
'([ "Midi all" LilyPond-command-all-midi t])
))
+;;; 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."
(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-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)
+ (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.
+ (if (not (string-match "XEmacs\\|Lucid" emacs-version))
+ (progn
+ (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")
- ;; run the mode hook. LilyPond-mode-hook use is deprecated
+ ;; 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))
+
+ ;; run the mode hook. LilyPond-mode-hook use is deprecated
(run-hooks 'LilyPond-mode-hook))
(defun LilyPond-version ()
projects / lilypond.git / blobdiff