util.el

(global-set-key (kbd "s-f") (lambda () (interactive) (sclang-eval-string "s.freqscope")))
(global-set-key (kbd "s-C-s") (lambda () (interactive) (sclang-eval-string "Server.local.makeGui;Server.internal.makeGui")))
(global-set-key (kbd "s-y") (lambda () (interactive) 
			      (sc-eval-paragraph)
			      (lap-stopwatch)))
(global-set-key (kbd "C-s-y") 'clear-stopwatch)
(global-set-key (kbd "s-w") 'show-stopwatch)
(global-set-key (kbd "s-e") 'replace-with-twice)
(global-set-key (kbd "C-s-e") 'replace-with-half)
(global-set-key (kbd "s-h") 'sclang-eval-line)
(global-set-key (kbd "C-s-h") 'sc-eval-paragraph)
(define-key global-map (kbd "s-j")   'sc-ace-jump-to-eval)
(define-key global-map (kbd "s-C-j") 'sc-stop-then-ace-jump-to-eval)
(define-key global-map (kbd "s-m")   'sc-replace-mousex)

(defvar sc-stopwatch ())
(defvar sc-rpm 120)
(defun clear-stopwatch ()
  (interactive)
  (setq sc-stopwatch ())
  (lap-stopwatch))

(defun lap-stopwatch ()
  (add-to-list 'sc-stopwatch (time-to-seconds (current-time))))

(defun show-stopwatch ()
  (interactive)
  (insert (s-join ", "
		  (let* ((xs sc-stopwatch)
			 (c (* 4 1.0))
			 (ds (reverse (-zip-with '- xs (cdr xs))))
			 (rps (/ 60.0 sc-rpm)))
		    (->> ds
		      (--map (/ (* it c) rps))
		      (--map (/ (round it) c))
		      (--map (format "%s" it)))))))

(defun map-region-as-number (code input)
  (->> input
    (s-split ",")
    (--map (s-trim it))
    (--map (string-to-number it))
    (--map (eval (read code)))
    (--map (format "%s" it))
    (s-join ", ")))

(defun replace-region (fn)
  (let* ((before (buffer-substring-no-properties (region-beginning) (region-end)))
	 (after (funcall fn before)))
    (delete-region (region-beginning) (region-end))
    (insert after)))

(defun replace-with-function (code)
  (replace-region (-partial 'map-region-as-number code)))

(defun replace-with-twice ()
  (interactive)
  (replace-with-function "(* it 2)"))

(defun replace-with-half ()
  (interactive)
  (replace-with-function "(/ it 2.0)"))

(defun replace-with-ask ()
  (interactive)
  (replace-with-function (read-from-minibuffer "function:")))

(defadvice sclang-eval-string (before sc-lap-time)
  (lap-stopwatch))

(ad-activate 'sclang-eval-string)
(ad-deactivate 'sclang-eval-string)

(custom-set-variables '(sclang-eval-line-forward nil))

(defvar sc-jump-point nil
 "sc-ace-jump-to-evalの開始時点の位置。同時にフラグでもある。")

(defun ace-jump-mode-end-hook--sc-eval ()
  (when sc-jump-point
    (call-interactively 'set-mark-command)
    (forward-sexp)
    (sclang-eval-region)
    (pop-mark)
    (ace-jump-mode-pop-mark)
    (setq sc-jump-point nil)))

(add-hook 'ace-jump-mode-end-hook 'ace-jump-mode-end-hook--sc-eval)

(defun sc-ace-jump-to-eval ()
 (interactive)
 (setq sc-jump-point (point))
 (ace-jump-char-mode 40))

(defun sc-stop-then-ace-jump-to-eval ()
  (interactive)
;  (sclang-main-stop)
  (sc-free-last-node)
  (sc-ace-jump-to-eval))

(defun sc-eval-paragraph ()
  (interactive)
  (let ((b (point)))
    (er/mark-text-paragraph)
    (sclang-eval-region)
    (pop-mark)
    (goto-char b)))

(defun sc-replace-mousex ()
  (interactive)
  (forward-word)
  (search-backward "Mouse")
  (let ((b (point)))
    (search-forward "poll")
    (sc-replace-ugen b (point) "MouseX" "MouseY")))

(defun sc-replace-ugen (region-b region-e &rest ugens)
 (-each ugens
        (lambda (ugen)
          (ignore-errors
            (sc-replace-region-at region-b region-e
                                  (lambda (code)
                                    (if (s-contains? ugen code)
                                        (sc-extract-last-poll-output ugen)
                                      code)))))))

(defun sc-extract-last-poll-output (ugen-name)
 (with-current-buffer "*SCLang:PostBuffer*"
   (end-of-buffer)
   (search-backward (s-concat "UGen(" ugen-name ")"))
   (let ((s (search-forward ": ")))
     (end-of-line)
     (buffer-substring-no-properties s (point)))))

(defun sc-replace-region-at (region-beginning region-end fn)
 (let* ((before (buffer-substring-no-properties region-beginning region-end))
        (after (funcall fn before)))
   (delete-region region-beginning region-end)
   (insert after)))

;; SynthDef(\\free, { |trig=0, id=1000|
;;     Free.kr(Impulse.kr(trig), id)
;; }).store;

(defun sc-create-stopper ()
  (interactive)
  (sclang-eval-string "
~stopper=Synth(\\free);
~stop = {|id|
  ~stopper.set(\\trig,0, \\id, id);
  ~stopper.set(\\trig,1, \\id, id); 
  ~stopper.set(\\trig,0, \\id, id);
}"))

(defun sc-free-last-node ()
  (interactive)
  (sclang-eval-string "s.queryAllNodes")
  (run-at-time 0.2 nil 
	       (lambda ()
		 (with-current-buffer "*SCLang:PostBuffer*"
		   (end-of-buffer)
		   (search-backward "NODE TREE")
		   (search-forward "group" nil t 2)
		   (foreign-regexp/search/forward "^\\W+\\d{4,} (?!free)")
		   (backward-word)
		   (sc-free-node
		    (substring-no-properties (word-at-point)))))))

(defun sc-free-node (id)
  (message id)
  (sclang-eval-string (format "~stopper.set(\\trig, 1, \\id, %s)" id))
  (sleep-for 0 100)
  (sclang-eval-string (format "~stopper.set(\\trig, 0, \\id, %s)" id)))


(global-set-key (kbd "s-c") 'sc-create-stopper)
(global-set-key (kbd "s-.") 'sc-free-last-node)
(global-set-key (kbd "C-s-.") 'sclang-main-stop)
(define-key sclang-extensions-mode-map (kbd "s-.") nil)