Hi folks

I just checked in this revised version of the emacs stuff, but I thought
I'd send it around, partly to expose my new email address, but mostly
because I can't actually test whether the new version solves the problem
on Windows, and I'd quite like to know.

I think the problem was the modeline hack, which seemed to require two
hooks to be executed in a particular order (down hook requests modeline
update, then click hook executes it), with a machine action (update
modeline) in between. On Windows, however, the modeline update wasn't
happening unless there was a good long gap between the execution of the
two hooks.

Now I can get hold of the current line number without grabbing
the modeline, it can all be done the sensible way, and on one hook. I've
put the action on the click hook. But maybe it should be the down hook.

Anyhow, I hope this fixes it.

Cheers

Conor

--
http://www.cs.rhul.ac.uk/~conor
(load "emacs-epigram.elc")

(defun epigram-send-input ()
  (with-current-buffer underneath-buffer
    (cond ((equal "" epigram-queue))
          ((= (point) (point-max))
             (insert epigram-queue)
             (setq epigram-queue "")
             (comint-send-input)))
))

(defun epigram-queue-input (x)
  (setq epigram-queue (concat epigram-queue x "\n"))
  (cond (epigram-ready (epigram-send-input)))
)

(define-derived-mode epigram-mode fundamental-mode "Epigram"
;  (setq modeline-format "(epigram-cursor %l %c)")
;  (make-local-hook 'mouse-track-down-hook)
  (make-local-hook 'mouse-track-click-hook)
  (make-local-variable 'epigram-point)
  (make-local-variable 'epigram-xy-point)
  (make-local-variable 'epigram-name)
  (setq mouse-track-click-hook
    '(epigram-click-hook)); default-mouse-track-click-hook))
;  (setq mouse-track-down-hook
;    '(epigram-down-hook)); default-mouse-track-down-hook))
  (setq truncate-lines t)
  (toggle-read-only 1)
  (set-keymap-default-binding epigram-mode-map 'epigram-keystroke)
  (local-set-key [button1] 'mouse-track)
)


(defun epigram-keystroke () (interactive)
  (epigram-queue-input (epigram-event (elt (this-command-keys) 0)))
  ; (with-current-buffer underneath-buffer
    ; (goto-char (point-max))
    ; (insert (epigram-event (elt (this-command-keys) 0)))
    ; (insert "\n")
    ; (comint-send-input)
  ; )
)

(defun epigram-idle-hook ()
  (with-current-buffer underneath-buffer
    (let ((keeper (point)))
      (goto-char underneath-do-from)
      (setq underneath-do-from (doit-or-not))
      (goto-char keeper)
    )
  )
  (epigram-send-input)
)

(defun install-epigram ()
  (interactive)
  (comint-run epigram-executable)
  (setq underneath-buffer (current-buffer))
  (setq underneath-do-from (point))
  (add-hook 'pre-idle-hook 'epigram-idle-hook)
  (setq epigram-buffer
     (generate-new-buffer (generate-new-buffer-name "*Epigram*")))
  (setq epigram-queue "")
  (setq epigram-ready t)
  (epigram (epigram-mode))
  (epigram (setq epigram-name "Epigram"))
  (setq horace-buffer
     (generate-new-buffer (generate-new-buffer-name "*Horace*")))
  (horace (epigram-mode))
  (horace (setq epigram-name "Horace"))
  (global-set-key [(control c) (control e)] 'glom-epigram) ; yuk
  (global-set-key [(control c) (control s)] 'shed-rectangle) ; yuk
  (global-set-key [(control c) (control b)] 'group-rectangle) ; yuk
  (global-set-key [(control c) (control c)] 'blat-epigram) ; yuk
  (global-set-key [(control c) (control r)] 'blat-region-epigram) ; yuk
  (global-set-key [(control c) r] 'blat-rectangle-epigram) ; yuk
)

(defun glom-epigram () (interactive)
  (delete-buffer-contents)
  (insert-buffer epigram-buffer)
)

(defun blat-epigram () (interactive)
  (setq blat-buffer (current-buffer))
  (with-current-buffer underneath-buffer
    (insert "data\n")
    (insert-buffer blat-buffer)
    (goto-char (point-max))
    (cond ((> (current-column) 0) (insert "\n")))
    (insert "][][][][][\n")
    (comint-send-input)
  )
)

(defun blat-region-epigram () (interactive)
  (copy-region-as-kill (point) (mark t))
  (with-current-buffer underneath-buffer
    (insert "data\n")
    (yank)
    (goto-char (point-max))
    (cond ((> (current-column) 0) (insert "\n")))
    (insert "][][][][][\n")
    (comint-send-input)
  )
)

(defun blat-rectangle-epigram () (interactive)
  (cond ((> (point) (mark t))
           (setq epi-rect (extract-rectangle (mark t) (point))))
        (t (setq epi-rect (extract-rectangle (point) (mark t)))))
  (with-current-buffer underneath-buffer
    (insert "data\n")
    (insert-rectangle epi-rect)
    (goto-char (point-max))
    (cond ((> (current-column) 0) (insert "\n")))
    (insert "][][][][][\n")
    (comint-send-input)
  )
)

(defun bracket-rectangle (o c r)
  (cond ((null r) nil)
        ((null (cdr r)) (cons (concat o (car r) c) nil))
        (t (cons (concat o (car r) "!") (bracket-rectangle "!" c (cdr r)))))
)

(defun shed-rectangle () (interactive)
  (cond ((> (point) (mark t)) (exchange-point-and-mark)))
  (setq epi-rect (delete-extract-rectangle (point) (mark t)))
  (insert-rectangle (bracket-rectangle "[" "]" epi-rect))
)

(defun group-rectangle () (interactive)
  (cond ((> (point) (mark t)) (exchange-point-and-mark)))
  (setq epi-rect (delete-extract-rectangle (point) (mark t)))
  (insert-rectangle (bracket-rectangle "(" ")" epi-rect))
)


(defun start-epigram ()
  (epigram (sneakily (delete-buffer-contents)))
)

(defmacro epigram (x) (list 'with-current-buffer 'epigram-buffer x))
(defmacro horace (x) (list 'with-current-buffer 'horace-buffer x))
(defmacro sneakily (x) (list 'progn
                             '(toggle-read-only -1)
                             x
                             '(toggle-read-only 1)))

(defun delete-buffer-contents ()
  (delete-region (point-min) (point-max))
)

(defun epigram-xy (x y)
  (setq epigram-point (point))
  (setq epigram-xy-point (goto-xy x y))
  (goto-char epigram-point)
  epigram-xy-point
)

(defun epigram-click-hook (e n)
  (mouse-set-point e)
  (epigram-cursor (line-number) (current-column))
  ()
)

;(defun epigram-click-hook (e n)
;  (eval (car (read-from-string generated-modeline-string)))
;  ()
;)

;(defun epigram-down-hook (e n)
;  (mouse-set-point e)
;  (redraw-modeline)
;  ()
;)

(defun epigram-cursor (l c)
  (epigram-queue-input
    (concat "click " epigram-name " "
      (number-to-string mouse-track-click-count) " "
      (number-to-string c) " " (number-to-string (- l 1))
    )
  )
  (try-to-make-buf-selected epigram-buffer)
)

Reply via email to