--- /dev/null
+;; $RCSfile: lyqi-mode.el,v $
+;; $Revision: 1.9 $
+;; $Date: 2004/03/14 15:14:55 $
+;; $Author: nicolas $
+;;;
+;;; Part of lyqi, a major emacs mode derived from LilyPond-Mode,
+;;; for quick note insertion while editing GNU LilyPond music scores.
+;;;
+;;; (c) copyright 2003 Nicolas Sceaux <nicolas.sceaux@free.fr>
+;;; See http://nicolas.sceaux.free.fr/lilypond/
+;;;
+
+(defgroup lyqi nil
+ "LilyPond quick insert mode."
+ :prefix "lyqi-"
+ :group 'applications)
+
+(eval-when-compile (require 'cl))
+(require 'lyqi-base)
+(require 'lyqi-parser)
+(require 'lyqi-editor)
+(require 'lyqi-midi)
+(require 'lyqi-rumor)
+
+(defconst lyqi-version "0.2.5")
+
+(defconst lyqi-languages
+ '(nederlands english deutsch norsk svenska italiano catalan espanol)
+ "Possible languages for writing LilyPond note names.")
+
+(defcustom lyqi-self-inserting-keys "()<>~{}|[] "
+ "Self inserting keys in lyqi-mode-map."
+ :group 'lyqi
+ :type 'string)
+
+(defcustom lyqi-self-inserting-+-char-keys "-_^\\"
+ "Self inserting keys, after which the user is asked an extra char to insert."
+ :group 'lyqi
+ :type 'string)
+
+(defcustom lyqi-self-inserting-+-string-keys
+ '((?- "\C-c-") (?_ "\C-c_") (?^ "\C-c^") (?\\ "\C-c\\") (?# "#") (?\" "\"" "\""))
+ "Self inserting keys, after which the user is asked an extra string to insert."
+ :group 'lyqi)
+
+(defcustom lyqi-force-duration t
+ "Force duration to appear when inserting a note"
+ :group 'lyqi
+ :type 'boolean)
+
+(defcustom lyqi-relative-octave-default nil
+ "Relative or absolute octave in lilypond insert mode by default?"
+ :group 'lyqi
+ :type 'boolean)
+
+(defcustom lyqi-default-language 'nederlands
+ "The default language for writing LilyPond note names."
+ :group 'lyqi
+ :options lyqi-languages
+ :type 'symbol)
+
+(defvar lyqi-editing-state nil
+ "The current editing state: language, octave mode, etc.")
+
+(defvar lyqi-mudela-editor nil
+ "A mudela editor.")
+
+(defvar lyqi-mudela-parser nil
+ "A rudimentary mudela parser")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; lilypond-quick-insert-mode interactive functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmacro with-GNUEmacs (&rest body)
+ (if (string-match "GNU Emacs" (version)) `(progn ,@body)))
+
+(defmacro with-XEmacs (&rest body)
+ (if (string-match "XEmacs" (version)) `(progn ,@body)))
+
+(with-XEmacs
+ (defun my-get-key (fn)
+ "Returns the key (a string) binded to `fn'"
+ (let ((keys (where-is-internal fn nil t)))
+ (and keys (my-join (mapcar (lambda (key)
+ (if (consp key)
+ (format "%s-%s"
+ (upcase (substring (symbol-name (car key)) 0 1))
+ (symbol-name (cadr key)))
+ (symbol-name key)))
+ (append keys nil)) " ")))))
+(with-GNUEmacs
+ (defun my-get-key (fn)
+ "Returns the key (a string) binded to `fn'"
+ (let ((keys (where-is-internal fn nil t)))
+ (and keys (my-join (mapcar (lambda (key) (if (and (<= 1 key) (<= key 26))
+ (format "C-%c" (+ 96 key))
+ (char-to-string key)))
+ keys) " ")))))
+
+(defun lyqi-display-state ()
+ "Display current state (language used, octave mode) and help commands in the minibuffer."
+ (message "lyqi-%s [%s,%s pitches,midi %s] Press %s to quit, %s for help."
+ lyqi-version
+ (slot-value lyqi-editing-state 'language)
+ (if (slot-value lyqi-editing-state 'relative-octave) "relative" "absolute")
+ (if lyqi-midi-on "on" "off")
+ (my-get-key 'lyqi-quit)
+ (my-get-key 'lyqi-help)))
+
+;; (defmacro with-lyqi-interactive (&rest body)
+;; "Utility to make a lyqi interactive command, with message display at the end."
+;; `(progn
+;; (interactive)
+;; ,@body
+;; (lyqi-display-state)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; note, rest, skips insertion
+
+(defun lyqi-insert-note (pitch)
+ "Insert a new mudela note of pitch `pitch'."
+ (let ((note (make-note lyqi-mudela-editor pitch)))
+ (word-insert lyqi-mudela-editor note)
+ (when lyqi-midi-on
+ (play-note note t))
+ (lyqi-display-state)))
+
+(defun lyqi-insert-note-do ()
+ "Insert a new do / c note at point."
+ (interactive)
+ (lyqi-insert-note 0))
+
+(defun lyqi-insert-note-re ()
+ "Insert a new re / d note at point."
+ (interactive)
+ (lyqi-insert-note 1))
+
+(defun lyqi-insert-note-mi ()
+ "Insert a new mi / e note at point."
+ (interactive)
+ (lyqi-insert-note 2))
+
+(defun lyqi-insert-note-fa ()
+ "Insert a new fa / f note at point."
+ (interactive)
+ (lyqi-insert-note 3))
+
+(defun lyqi-insert-note-sol ()
+ "Insert a new sol / g note at point."
+ (interactive)
+ (lyqi-insert-note 4))
+
+(defun lyqi-insert-note-la ()
+ "Insert a new la / a note at point."
+ (interactive)
+ (lyqi-insert-note 5))
+
+(defun lyqi-insert-note-si ()
+ "Insert a new si / b note at point."
+ (interactive)
+ (lyqi-insert-note 6))
+
+(defun lyqi-insert-rest ()
+ "Insert a rest at point."
+ (interactive)
+ (word-insert lyqi-mudela-editor (make-rest lyqi-mudela-editor))
+ (lyqi-display-state))
+
+(defun lyqi-insert-skip ()
+ "Insert a skip at point."
+ (interactive)
+ (word-insert lyqi-mudela-editor (make-skip lyqi-mudela-editor))
+ (lyqi-display-state))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; note, rest, skips update
+
+;; (defun lyqi-change-duration (duration)
+;; "Change the last word duration, if any, and if possible."
+;; (with-word-update lyqi-mudela-editor the-word
+;; (set-duration the-word duration)))
+(defun lyqi-change-duration (duration)
+ "Change the last word duration, if any, and if possible."
+ (with-word-update lyqi-mudela-editor the-word
+ (set-duration the-word duration)))
+
+(defun lyqi-change-duration-1 ()
+ "Change the previous word duration to 1."
+ (interactive)
+ (lyqi-change-duration 1)
+ (lyqi-display-state))
+
+(defun lyqi-change-duration-2 ()
+ "Change the previous word duration to 2."
+ (interactive)
+ (lyqi-change-duration 2)
+ (lyqi-display-state))
+
+(defun lyqi-change-duration-4 ()
+ "Change the previous word duration to 4."
+ (interactive)
+ (lyqi-change-duration 3)
+ (lyqi-display-state))
+
+(defun lyqi-change-duration-8 ()
+ "Change the previous word duration to 8."
+ (interactive)
+ (lyqi-change-duration 4)
+ (lyqi-display-state))
+
+(defun lyqi-change-duration-16 ()
+ "Change the previous word duration to 16."
+ (interactive)
+ (lyqi-change-duration 5)
+ (lyqi-display-state))
+
+(defun lyqi-change-duration-32 ()
+ "Change the previous word duration to 32."
+ (interactive)
+ (lyqi-change-duration 6)
+ (lyqi-display-state))
+
+(defun lyqi-change-duration-64 ()
+ "Change the previous word duration to 64."
+ (interactive)
+ (lyqi-change-duration 7)
+ (lyqi-display-state))
+
+(defun lyqi-change-duration-128 ()
+ "Change the previous word duration to 128."
+ (interactive)
+ (lyqi-change-duration 8)
+ (lyqi-display-state))
+
+(defun lyqi-change-dots ()
+ "Increase modulo 5 the previous word dot number."
+ (interactive)
+ (with-word-update lyqi-mudela-editor the-word
+ (set-dots the-word))
+ (lyqi-display-state))
+
+(defun lyqi-change-alteration-up ()
+ "Increase, if possible, the last note alteration."
+ (interactive)
+ (with-word-update lyqi-mudela-editor the-note
+ (set-alteration-up the-note)
+ (when lyqi-midi-on
+ (play-note the-note t)))
+ (lyqi-display-state))
+
+(defun lyqi-change-alteration-down ()
+ "Decrease, if possible, the last note alteration."
+ (interactive)
+ (with-word-update lyqi-mudela-editor the-note
+ (set-alteration-down the-note)
+ (when lyqi-midi-on
+ (play-note the-note t)))
+ (lyqi-display-state))
+
+(defun lyqi-change-alteration-natural ()
+ "Set, if possible, the last note alteration to natural."
+ (interactive)
+ (with-word-update lyqi-mudela-editor the-note
+ (set-alteration-natural the-note)
+ (when lyqi-midi-on
+ (play-note the-note t)))
+ (lyqi-display-state))
+
+(defun lyqi-change-octave-up ()
+ "Increase the last note octave."
+ (interactive)
+ (with-word-update lyqi-mudela-editor the-note
+ (set-octave-up the-note)
+ (when lyqi-midi-on
+ (play-note the-note t)))
+ (lyqi-display-state))
+
+(defun lyqi-change-octave-down ()
+ "Decrease the last note octave."
+ (interactive)
+ (with-word-update lyqi-mudela-editor the-note
+ (set-octave-down the-note)
+ (when lyqi-midi-on
+ (play-note the-note t)))
+ (lyqi-display-state))
+
+(defun lyqi-change-octave-zero ()
+ "Set the last note octave to zero."
+ (interactive)
+ (with-word-update lyqi-mudela-editor the-note
+ (set-octave-zero the-note)
+ (when lyqi-midi-on
+ (play-note the-note t)))
+ (lyqi-display-state))
+
+(defun lyqi-change-reminder-alt ()
+ "Change the last note's reminder alteration state."
+ (interactive)
+ (with-word-update lyqi-mudela-editor the-note
+ (set-reminder-alt the-note))
+ (lyqi-display-state))
+
+(defun lyqi-change-cautionary-alt ()
+ "Change the last note's cautionary alteration state."
+ (interactive)
+ (with-word-update lyqi-mudela-editor the-note
+ (set-cautionary-alt the-note))
+ (lyqi-display-state))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+
+(with-XEmacs
+ (defun my-read-char-exclusive (prompt)
+ (let ((event (next-event nil prompt)))
+ (while (not (key-press-event-p event))
+ (next-event event prompt))
+ (event-to-character event))))
+(with-GNUEmacs
+ (defun my-read-char-exclusive (prompt)
+ (read-char-exclusive prompt)))
+
+(defun lyqi-insert-tuplet ()
+ "Interactively inserts a \\times x/y {"
+ (interactive)
+ (let ((x ""))
+ (lyqi-just-one-space)
+ (insert "\\times ")
+ (while (not (and (string< x "9") (string< "0" x)))
+ (setq x (char-to-string (my-read-char-exclusive
+ "Insert a number for the numerator (\"x/\")"))))
+ (insert (format "%s/" x)) (setq x "/")
+ (while (not (and (string< x "9") (string< "0" x)))
+ (setq x (char-to-string (my-read-char-exclusive
+ "Insert a number for the denominator (\"/y\")"))))
+ (insert (format "%s { " x)))
+ (lyqi-display-state))
+
+(defun lyqi-word-forward ()
+ "Move to the following mudela word end, if any, otherwise to the end of the
+following text word."
+ (interactive)
+ (unless (re-search-forward (slot-value lyqi-mudela-parser 'regexp) nil t)
+ (forward-word 1))
+ (lyqi-display-state))
+
+(defun lyqi-word-backward ()
+ "Move to the previous mudela word beginning, if any, otherwise to the beginning of the
+previous text word."
+ (interactive)
+ (unless (re-search-backward (slot-value lyqi-mudela-parser 'regexp) nil t)
+ (backward-word 1))
+ (lyqi-display-state))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+
+(defun my-next (elt seq)
+ "Returns the element following `elt' in `seq'.
+If it is the last, returns the first element of the sequence."
+ (let ((nexts (cdr (member elt seq))))
+ (if (consp nexts)
+ (car nexts)
+ (car seq))))
+
+(defun lyqi-switch-language ()
+ "Select the next mudela language in `lyqi-languages'."
+ (interactive)
+ (setf lyqi-default-language
+ (my-next (slot-value lyqi-editing-state 'language) lyqi-languages))
+ (set-language lyqi-editing-state lyqi-default-language)
+ (update-regexp lyqi-mudela-parser)
+ (lyqi-display-state))
+
+(defun lyqi-switch-octave-mode ()
+ "Switch between relative and absolute octave modes."
+ (interactive)
+ (setf (slot-value lyqi-editing-state 'relative-octave)
+ (not (slot-value lyqi-editing-state 'relative-octave)))
+ (lyqi-display-state))
+
+(defun my-center-string (str len)
+ "Makes a centered string from `str', of length `len'"
+ (let* ((inner-str (if (< (length str) len)
+ str
+ (substring str 0 len)))
+ (right-space (/ (- len (length inner-str)) 2))
+ (left-space (- len right-space (length inner-str))))
+ (format "%s%s%s"
+ (make-string left-space (string-to-char " "))
+ inner-str
+ (make-string right-space (string-to-char " ")))))
+
+(defun lyqi-help ()
+ "Display a help message in a dedicated buffer."
+ (interactive)
+ (describe-mode)
+;; (with-output-to-temp-buffer "*Help*"
+;; (princ "LilyPond quick insert mode
+;; Note entry:
+;; | | | | | | | | | | | | |
+;; | | | | | | | | | | | | |
+;; | |_| |_| | |_| |_| |_| |
+;; | | | | | | | |
+;; |___|___|___|___|___|___|___|\n")
+
+;; (princ (format "pitch keys: %s \n\n"
+;; (my-join (mapcar (lambda (fn)
+;; (my-center-string (format "`%s'" (my-get-key fn)) 3))
+;; '(lyqi-insert-note-do
+;; lyqi-insert-note-re
+;; lyqi-insert-note-mi
+;; lyqi-insert-note-fa
+;; lyqi-insert-note-sol
+;; lyqi-insert-note-la
+;; lyqi-insert-note-si)) " ")))
+;; (princ (format "duration keys: %s\n"
+;; (my-join (mapcar (lambda (fn)
+;; (my-center-string (format "`%s'" (my-get-key fn)) 3))
+;; '(lyqi-change-duration-1
+;; lyqi-change-duration-2
+;; lyqi-change-duration-4
+;; lyqi-change-duration-8
+;; lyqi-change-duration-16
+;; lyqi-change-duration-32
+;; lyqi-change-duration-64
+;; lyqi-change-duration-128)) " ")))
+;; (princ (format " %s\n"
+;; (my-join (mapcar (lambda (num)
+;; (my-center-string
+;; (int-to-string (expt 2 (- num 1))) 3))
+;; '(1 2 3 4 5 6 7 8)) "|")))
+;; (princ (format "alteration: `%s' flat
+;; `%s' sharp\n
+;; `%s' force reminder alteration\n
+;; `%s' force cautionary alteration\n"
+;; (my-get-key 'lyqi-change-alteration-down)
+;; (my-get-key 'lyqi-change-alteration-up)
+;; (my-get-key 'lyqi-change-reminder-alt)
+;; (my-get-key 'lyqi-change-cautionary-alt)))
+;; (princ (format "dot key: `%s'\n" (my-get-key 'lyqi-change-dots)))
+;; (princ (format "octave keys: `%s' down
+;; `%s' up\n"
+;; (my-get-key 'lyqi-change-octave-down)
+;; (my-get-key 'lyqi-change-octave-up)))
+;; (princ (format "rests: `%s'\n" (my-get-key 'lyqi-insert-rest)))
+;; (princ (format "skips: `%s'\n" (my-get-key 'lyqi-insert-skip)))
+;; (princ (format "tuplets: `%s'\n" (my-get-key 'lyqi-insert-tuplet)))
+;; (princ (format "self inserting keys: `%s'\n" (my-join (split-string lyqi-self-inserting-keys "") "' `")))
+;; (princ "\nOther bindings:\n")
+;; (princ (format "absolute/relative octave switch: `%s'\n"
+;; (my-get-key 'lyqi-switch-octave-mode)))
+;; (princ (format "language switch: `%s'\n" (my-get-key 'lyqi-switch-language)))
+;; (princ (format "help: `%s'\n" (my-get-key 'lyqi-help)))
+;; (princ (format "Midi note playing start/stop: `%s'\n"
+;; (my-get-key 'lyqi-midi-start-stop)))
+;; (princ (format "back to LilyPond-mode: `%s'\n" (my-get-key 'lyqi-quit)))
+;; (princ (format "Transpose region: `%s'\n" (my-get-key 'lyqi-transpose-region)))
+ (lyqi-display-state))
+
+(defun lyqi-quit ()
+ "Quit lilypond-quick-insert-mode, back to LilyPond-mode"
+ (interactive)
+ (LilyPond-mode))
+
+(defun lyqi-relative-to-absolute-region ()
+ "Rewrite region with absolute octave mode instead of relative octave mode.
+An octave transposition may be required afterward."
+ (interactive)
+ (when (not (slot-value lyqi-editing-state 'relative-octave))
+ (lyqi-switch-octave-mode))
+ (change-octave-mode-region lyqi-mudela-editor (region-beginning) (region-end))
+ (lyqi-display-state))
+
+(defun lyqi-absolute-to-relative-region ()
+ "Rewrite region with relative octave mode instead of absolute octave mode."
+ (interactive)
+ (when (slot-value lyqi-editing-state 'relative-octave)
+ (lyqi-switch-octave-mode))
+ (change-octave-mode-region lyqi-mudela-editor (region-beginning) (region-end))
+ (lyqi-display-state))
+
+(defun lyqi-transpose-region-aux (from-note to-note)
+ "Transpose the current region, the interval being defined by `from-note'
+and `to-note', two mudela-notes."
+ (when to-note
+ (let ((note-diff (+ (- (slot-value to-note 'pitch)
+ (slot-value from-note 'pitch))
+ (* 7 (- (slot-value to-note 'octave)
+ (slot-value from-note 'octave)))))
+ (exact-pitch-diff (- (midi-pitch to-note) (midi-pitch from-note))))
+ (transpose-region lyqi-mudela-editor note-diff exact-pitch-diff (region-beginning) (region-end)))))
+
+(defun lyqi-transpose-region (to-note-str)
+ "Interactively transpose the current region. The user is asked the transposition interval,
+starting from c/do."
+ (interactive "sTranspose to: ")
+ (let ((from-note (make-instance 'mudela-note :pitch 0 :octave 0))
+ (to-note (parse-string lyqi-mudela-parser to-note-str (make-instance 'mudela-note-state :octave 0))))
+ (lyqi-transpose-region-aux from-note to-note)))
+
+;;; by Reuben Thomas <rrt@sc3d.org>
+(defun lyqi-transpose-interval-region (trans)
+ "Interactively transpose the current region. The user is asked the transposition interval in tones."
+ (interactive "sTranspose by interval (tones[+]|[-]) : ")
+ (let* ((interval (string-to-int trans))
+ (adj (substring trans -1))
+ (alt (cond ((equal adj "+") 3)
+ ((equal adj "-") 1)
+ (t 2)))
+ (oct (/ interval 7))
+ (tone (% interval 7)))
+ (when (< tone 0)
+ (setq tone (+ tone 7))
+ (setq oct (- oct 1)))
+ (let ((from-note (make-instance 'mudela-note :pitch 0 :octave 0))
+ (to-note (make-instance 'mudela-note :pitch tone :octave oct :alteration alt)))
+ (lyqi-transpose-region-aux from-note to-note)))
+ (lyqi-display-state))
+
+(defun lyqi-play-back-region ()
+ "If midi is on, play back notes in region."
+ (interactive)
+ (when (process-runningp lyqi-midi-keyboard)
+ (mapcar 'play-note (parse-region lyqi-mudela-parser (region-beginning) (region-end)))))
+
+(defun lyqi-change-language-region ()
+ "Change note language in region. The user is asked for source and destination languages."
+ (interactive)
+ (let* ((current-lang (slot-value lyqi-editing-state 'language))
+ (next-lang (my-next current-lang lyqi-languages))
+ (lang-collection (mapcar (lambda (lang) (list (symbol-name lang))) lyqi-languages))
+ (from-lang (intern (completing-read (format "Change from language [%s]: " current-lang)
+ lang-collection nil t nil nil (symbol-name current-lang))))
+ (to-lang (intern (completing-read (format "Change from language %s to [%s]: " from-lang next-lang)
+ lang-collection nil t nil nil (symbol-name next-lang)))))
+ (change-language-region lyqi-mudela-editor from-lang to-lang (region-beginning) (region-end)))
+ (lyqi-display-state))
+
+;; (defun lyqi-self-insert-plus-char (char))
+;; (defun lyqi-self-insert-plus-string (char) &optional ending)
+
+;;; Rumor
+
+(defun lyqi-rumor-session-stop ()
+ "Stop a running rumor session."
+ (interactive)
+ (process-stop lyqi-rumor-process)
+ (define-key lyqi-mode-map " " 'self-insert-command))
+
+(defun lyqi-rumor-session-start ()
+ "Start a rumor session. Press SPC to stop the session"
+ (interactive)
+ (define-key lyqi-mode-map " " 'lyqi-rumor-session-stop)
+ (process-start lyqi-rumor-process))
+
+(defun lyqi-rumor-set-legato ()
+ "Change rumor's legato parameter."
+ (interactive)
+ (let ((legato (with-slots (legato) lyqi-rumor-process
+ (setf (slot-value lyqi-rumor-process 'legato)
+ (not legato)))))
+ (message "rumor: legato mode set %s for next session." (if legato "on" "off"))
+ legato))
+
+(defun lyqi-rumor-set-no-dots ()
+ "Change rumor's no-dots parameter."
+ (interactive)
+ (let ((no-dots (with-slots (no-dots) lyqi-rumor-process
+ (setf (slot-value lyqi-rumor-process 'no-dots)
+ (not no-dots)))))
+ (message "rumor: dots %sshown in next session." (if no-dots "not " ""))
+ no-dots))
+
+(defun lyqi-rumor-set-flat ()
+ "Change rumor's flat parameter."
+ (interactive)
+ (let ((flat (with-slots (flat) lyqi-rumor-process
+ (setf (slot-value lyqi-rumor-process 'flat)
+ (not flat)))))
+ (message "rumor: flat mode set %s for next session." (if flat "on" "off"))
+ flat))
+
+(defun lyqi-rumor-set-grain (grain-str)
+ "Set rumor's grain."
+ (interactive "sRumor's new grain: ")
+ (let ((grain (setf (slot-value lyqi-rumor-process 'grain)
+ (string-to-number grain-str))))
+ (message "rumor: grain set to %d for next session" grain)
+ grain))
+
+(defun lyqi-rumor-set-tempo (tempo-str)
+ "Set rumor's tempo."
+ (interactive "sRumor's new tempo: ")
+ (let ((tempo (setf (slot-value lyqi-rumor-process 'tempo)
+ (string-to-number tempo-str))))
+ (message "rumor: tempo set to %d for next session" tempo)
+ tempo))
+
+(defun lyqi-rumor-set-alsa-port (alsa-port-str)
+ "Set rumor's alsa-port."
+ (interactive "sRumor's new alsa port: ")
+ (let ((port (setf (slot-value lyqi-rumor-process 'port)
+ (string-to-number alsa-port-str))))
+ (message "rumor: alsa port set to %d for next session" port)
+ port))
+
+(defun lyqi-rumor-set-meter (meter)
+ "Set rumor's meter."
+ (interactive "sRumor's new meter: ")
+ (setf (slot-value lyqi-rumor-process 'meter)
+ meter)
+ (message "rumor: meter set to %s for next session" meter)
+ meter)
+
+(defun lyqi-rumor-set-key (key)
+ "Set rumor's key."
+ (interactive "sRumor's new key (in dutsch): ")
+ (setf (slot-value lyqi-rumor-process 'key)
+ key)
+ (message "rumor: key set to %s for next session" key)
+ key)
+
+;;; Midi play back
+
+(defun lyqi-midi-start-stop ()
+ "Start or stop midi playing."
+ (interactive)
+ (if lyqi-midi-on
+ (lyqi-midi-stop)
+ (lyqi-midi-start))
+ (setq lyqi-midi-manually-off (not lyqi-midi-on))
+ (lyqi-display-state))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; lyqi-mode definition
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmacro lyqi-make-self-insert-+-char (key)
+ "Define a self-insert-<char>-+-char function, and "
+ (let ((fn-symb (intern (format "lyqi-%s-self-insert-+-char" key))))
+ `(progn
+ (defun ,fn-symb ()
+ ,(format "Insert the character %s and ask the user an extra character to insert." key)
+ (interactive)
+ (insert ,key)
+ (insert (char-to-string (my-read-char-exclusive "Following character: "))))
+ (define-key lyqi-mode-map ,key ',fn-symb))))
+
+(defmacro lyqi-make-self-insert-+-string (char key &optional end-string)
+ "Define a self-insert-<char>-+-char function, and "
+ (let ((fn-symb (intern (format "lyqi-%s-self-insert-+-string" (char-to-string char)))))
+ `(progn
+ (defun ,fn-symb ()
+ ,(format "Insert the character %c and ask the user an extra character to insert." char)
+ (interactive)
+ (insert ,(char-to-string char))
+ (insert (read-string "Following string: "))
+ ,(if end-string `(insert ,end-string)))
+ (define-key lyqi-mode-map ,key ',fn-symb))))
+
+(define-derived-mode lyqi-mode
+ LilyPond-mode "lyqi"
+ "Major mode for LilyPond quick note insert.
+\\{lyqi-mode-map}"
+ (make-local-variable 'lyqi-editing-state)
+ (make-local-variable 'lyqi-mudela-parser)
+ (make-local-variable 'lyqi-mudela-editor)
+
+ (setq lyqi-editing-state (make-instance 'mudela-editing-state
+ :translation-table mudela-translation-table
+ :relative-octave lyqi-relative-octave-default
+ :force-duration lyqi-force-duration))
+ (set-language lyqi-editing-state lyqi-default-language)
+ (setq lyqi-mudela-parser (make-mudela-parser lyqi-editing-state))
+ (setq lyqi-mudela-editor (make-instance 'mudela-editor
+ :editing-state lyqi-editing-state
+ :parser lyqi-mudela-parser
+ :note-state (make-instance 'mudela-note-state)))
+ ;; I don't know how to directly set a class slot !
+ ;; Is that a feature or a bug ? when I set a class allocated slot
+ ;; of a mother class instance, the slot is not also updated in child
+ ;; class instances...
+ (let ((c (make-instance 'mudela-note))
+ (r (make-instance 'mudela-rest))
+ (s (make-instance 'mudela-skip)))
+ (setf (slot-value c 'editing-state) lyqi-editing-state)
+ (setf (slot-value r 'editing-state) lyqi-editing-state)
+ (setf (slot-value s 'editing-state) lyqi-editing-state))
+
+ ;; midi start
+ (unless lyqi-midi-timidity
+ (cond (lyqi-midi-use-external-timidity-server
+ (setq lyqi-midi-timidity (make-instance 'external-timidity-server))
+ (setf (slot-value lyqi-midi-timidity 'seqport) lyqi-midi-external-timidity-port))
+ (t
+ (setq lyqi-midi-timidity (make-instance 'timidity-server
+ :command lyqi-midi-demon-command
+ :name "timidity")))))
+ (unless lyqi-midi-keyboard
+ (setq lyqi-midi-keyboard (make-instance 'mymidikbd
+ :command lyqi-midi-keyboard-command
+ :name "mymidikbd")))
+ (unless lyqi-rumor-process
+ (setq lyqi-rumor-process (make-instance 'rumor
+ :command lyqi-rumor-command
+ :name "rumor"
+ :grain lyqi-rumor-default-grain
+ :tempo lyqi-rumor-default-tempo
+ :legato lyqi-rumor-default-legato
+ :no-dots lyqi-rumor-default-no-dots
+ :flat lyqi-rumor-default-flat
+ :strip lyqi-rumor-default-strip
+ :meter lyqi-rumor-default-meter
+ :key lyqi-rumor-default-key
+ :alsa-port lyqi-rumor-default-alsa-port)))
+ (when (and (not lyqi-midi-manually-off)
+ lyqi-midi-enabled-default)
+ (lyqi-midi-start)))
+
+;; makes all the printing characters undefined.
+(suppress-keymap lyqi-mode-map t)
+;; rests and skips
+(define-key lyqi-mode-map "r" 'lyqi-insert-rest)
+(define-key lyqi-mode-map "s" 'lyqi-insert-skip)
+;; pitches : do re mi fa sol la si
+(define-key lyqi-mode-map "d" 'lyqi-insert-note-do)
+(define-key lyqi-mode-map "f" 'lyqi-insert-note-re)
+(define-key lyqi-mode-map "g" 'lyqi-insert-note-mi)
+(define-key lyqi-mode-map "h" 'lyqi-insert-note-fa)
+(define-key lyqi-mode-map "j" 'lyqi-insert-note-sol)
+(define-key lyqi-mode-map "k" 'lyqi-insert-note-la)
+(define-key lyqi-mode-map "l" 'lyqi-insert-note-si)
+;; alterations
+(define-key lyqi-mode-map "i" 'lyqi-change-alteration-up)
+(define-key lyqi-mode-map "e" 'lyqi-change-alteration-down)
+(define-key lyqi-mode-map "n" 'lyqi-change-alteration-natural)
+(define-key lyqi-mode-map "!" 'lyqi-change-reminder-alt)
+(define-key lyqi-mode-map "?" 'lyqi-change-cautionary-alt)
+;; octave
+(define-key lyqi-mode-map "'" 'lyqi-change-octave-up)
+(define-key lyqi-mode-map "," 'lyqi-change-octave-down)
+(define-key lyqi-mode-map "=" 'lyqi-change-octave-zero)
+;; durations: 1 2 4 8 16 32 64 128
+(define-key lyqi-mode-map "1" 'lyqi-change-duration-1)
+(define-key lyqi-mode-map "2" 'lyqi-change-duration-2)
+(define-key lyqi-mode-map "4" 'lyqi-change-duration-4)
+(define-key lyqi-mode-map "8" 'lyqi-change-duration-8)
+(define-key lyqi-mode-map "7" 'lyqi-change-duration-16)
+(define-key lyqi-mode-map "5" 'lyqi-change-duration-32)
+(define-key lyqi-mode-map "0" 'lyqi-change-duration-64)
+(define-key lyqi-mode-map "9" 'lyqi-change-duration-128)
+;; dots
+(define-key lyqi-mode-map "." 'lyqi-change-dots)
+;; tuplets
+(define-key lyqi-mode-map "\C-ct" 'lyqi-insert-tuplet)
+;; other bindings
+(define-key lyqi-mode-map "\C-co" 'lyqi-switch-octave-mode)
+(define-key lyqi-mode-map "\C-c\C-l" 'lyqi-switch-language)
+(define-key lyqi-mode-map "\C-cq" 'lyqi-quit) ; back to LilyPond-mode
+(define-key lyqi-mode-map "\C-ch" 'lyqi-help)
+(define-key lyqi-mode-map "\M-b" 'lyqi-word-backward)
+(define-key lyqi-mode-map "\M-f" 'lyqi-word-forward)
+(define-key lyqi-mode-map "\C-c\C-t" 'lyqi-transpose-region)
+(define-key lyqi-mode-map "\C-cm" 'lyqi-midi-start-stop)
+(define-key lyqi-mode-map "\C-cp" 'lyqi-play-back-region)
+;; prefix key for rumor commands
+(define-prefix-command 'ctl-c-p)
+(define-key lyqi-mode-map "\C-cr" ctl-c-p)
+(define-key lyqi-mode-map "\C-crs" 'lyqi-rumor-session-start)
+(define-key lyqi-mode-map "\C-crg" 'lyqi-rumor-set-grain)
+(define-key lyqi-mode-map "\C-crt" 'lyqi-rumor-set-tempo)
+(define-key lyqi-mode-map "\C-crl" 'lyqi-rumor-set-legato)
+(define-key lyqi-mode-map "\C-crd" 'lyqi-rumor-set-no-dots)
+(define-key lyqi-mode-map "\C-crf" 'lyqi-rumor-set-flat)
+(define-key lyqi-mode-map "\C-crm" 'lyqi-rumor-set-meter)
+(define-key lyqi-mode-map "\C-crk" 'lyqi-rumor-set-key)
+(define-key lyqi-mode-map "\C-crp" 'lyqi-rumor-set-alsa-port)
+;; self inserting keys
+(dolist (key (split-string lyqi-self-inserting-keys ""))
+ (define-key lyqi-mode-map key 'self-insert-command))
+(dolist (key (split-string lyqi-self-inserting-+-char-keys ""))
+ (eval `(lyqi-make-self-insert-+-char ,key)))
+(dolist (key-descr lyqi-self-inserting-+-string-keys)
+ (eval `(lyqi-make-self-insert-+-string ,@key-descr)))
projects / lib.git / blobdiff