Update of /project/climacs/cvsroot/climacs In directory common-lisp.net:/tmp/cvs-serv18067 Modified Files: gui.lisp climacs.asd cl-syntax.lisp Log Message: Moved various things from gui.lisp into developer-commands.lisp, file-commands.lisp, misc-commands.lisp (rather large...), search-commands.lisp, unicode-commands.lisp and window-commands.lisp. Also tried to get the .asd right. Additionally, removed "lisp" as a file-type for the Common Lisp syntax. Date: Sat Nov 12 10:34:35 2005 Author: dmurray Index: climacs/gui.lisp diff -u climacs/gui.lisp:1.194 climacs/gui.lisp:1.195 --- climacs/gui.lisp:1.194 Thu Nov 3 11:17:40 2005 +++ climacs/gui.lisp Sat Nov 12 10:34:34 2005 @@ -250,652 +250,43 @@ do (when (modified-p buffer) (setf (needs-saving buffer) t)))) -(define-command (com-overwrite-mode :name t :command-table editing-table) () - (with-slots (overwrite-mode) (current-window) - (setf overwrite-mode (not overwrite-mode)))) - -(set-key 'com-overwrite-mode - 'editing-table - '((:insert))) - -(define-command (com-not-modified :name t :command-table buffer-table) () - (setf (needs-saving (buffer (current-window))) nil)) - -(set-key 'com-not-modified - 'buffer-table - '((#\~ :meta :shift))) - -(define-command (com-set-fill-column :name t :command-table fill-table) - ((column 'integer :prompt "Column Number:")) - (set-fill-column column)) - -(set-key `(com-set-fill-column ,*numeric-argument-marker*) - 'fill-table - '((#\x :control) (#\f))) - -(defun set-fill-column (column) - (if (> column 1) - (setf (auto-fill-column (current-window)) column) - (progn (beep) (display-message "Set Fill Column requires an explicit argument.")))) - -(defun possibly-fill-line () - (let* ((pane (current-window)) - (buffer (buffer pane))) - (when (auto-fill-mode pane) - (let* ((fill-column (auto-fill-column pane)) - (point (point pane)) - (offset (offset point)) - (tab-width (tab-space-count (stream-default-view pane))) - (syntax (syntax buffer))) - (when (>= (buffer-display-column buffer offset tab-width) - (1- fill-column)) - (fill-line point - (lambda (mark) - (syntax-line-indentation mark tab-width syntax)) - fill-column - tab-width)))))) - -(defun insert-character (char) - (let* ((window (current-window)) - (point (point window))) - (unless (constituentp char) - (possibly-expand-abbrev point)) - (when (whitespacep char) - (possibly-fill-line)) - (if (and (slot-value window 'overwrite-mode) (not (end-of-line-p point))) - (progn - (delete-range point) - (insert-object point char)) - (insert-object point char)))) - -(define-command com-self-insert ((count 'integer)) - (loop repeat count do (insert-character *current-gesture*))) - -(define-command (com-beginning-of-line :name t :command-table movement-table) () - (beginning-of-line (point (current-window)))) - -(set-key 'com-beginning-of-line - 'movement-table - '((:home))) - -(set-key 'com-beginning-of-line - 'movement-table - '((#\a :control))) - -(define-command (com-end-of-line :name t :command-table movement-table) () - (end-of-line (point (current-window)))) - -(set-key 'com-end-of-line - 'movement-table - '((#\e :control))) - -(set-key 'com-end-of-line - 'movement-table - '((:end))) - -(define-command (com-delete-object :name t :command-table deletion-table) - ((count 'integer :prompt "Number of Objects") - (killp 'boolean :prompt "Kill?")) - (let* ((point (point (current-window))) - (mark (clone-mark point))) - (forward-object mark count) - (when killp - (kill-ring-standard-push *kill-ring* - (region-to-sequence point mark))) - (delete-region point mark))) - -(set-key `(com-delete-object ,*numeric-argument-marker* - ,*numeric-argument-p*) - 'deletion-table - '(#\Rubout)) - -(set-key `(com-delete-object ,*numeric-argument-marker* - ,*numeric-argument-p*) - 'deletion-table - '((#\d :control))) - -(define-command (com-backward-delete-object :name t :command-table deletion-table) - ((count 'integer :prompt "Number of Objects") - (killp 'boolean :prompt "Kill?")) - (let* ((point (point (current-window))) - (mark (clone-mark point))) - (backward-object mark count) - (when killp - (kill-ring-standard-push *kill-ring* - (region-to-sequence mark point))) - (delete-region mark point))) - -(set-key `(com-backward-delete-object ,*numeric-argument-marker* - ,*numeric-argument-p*) - 'deletion-table - '(#\Backspace)) - -(define-command (com-zap-to-object :name t :command-table deletion-table) () - (let* ((item (handler-case (accept 't :prompt "Zap to Object") - (error () (progn (beep) - (display-message "Not a valid object") - (return-from com-zap-to-object nil))))) - (current-point (point (current-window))) - (item-mark (clone-mark current-point)) - (current-offset (offset current-point))) - (search-forward item-mark (vector item)) - (delete-range current-point (- (offset item-mark) current-offset)))) - -(define-command (com-zap-to-character :name t :command-table deletion-table) () - (let* ((item-string (handler-case (accept 'string :prompt "Zap to Character") ; Figure out how to get #\d and d. (or 'string 'character)? - (error () (progn (beep) - (display-message "Not a valid string. ") - (return-from com-zap-to-character nil))))) - (item (subseq item-string 0 1)) - (current-point (point (current-window))) - (item-mark (clone-mark current-point)) - - (current-offset (offset current-point))) - (if (> (length item-string) 1) - (display-message "Using just the first character")) - (search-forward item-mark item) - (delete-range current-point (- (offset item-mark) current-offset)))) - -(set-key 'com-zap-to-character - 'deletion-table - '((#\z :meta))) - -(defun transpose-objects (mark) - (unless (beginning-of-buffer-p mark) - (when (end-of-line-p mark) - (backward-object mark)) - (let ((object (object-after mark))) - (delete-range mark) - (backward-object mark) - (insert-object mark object) - (forward-object mark)))) - -(define-command (com-transpose-objects :name t :command-table editing-table) () - (transpose-objects (point (current-window)))) - -(set-key 'com-transpose-objects - 'editing-table - '((#\t :control))) - -(define-command (com-backward-object :name t :command-table movement-table) - ((count 'integer :prompt "Number of Objects")) - (backward-object (point (current-window)) count)) - -(set-key `(com-backward-object ,*numeric-argument-marker*) - 'movement-table - '((#\b :control))) - -(set-key `(com-backward-object ,*numeric-argument-marker*) - 'movement-table - '((:left))) - -(define-command (com-forward-object :name t :command-table movement-table) - ((count 'integer :prompt "Number of Objects")) - (forward-object (point (current-window)) count)) - -(set-key `(com-forward-object ,*numeric-argument-marker*) - 'movement-table - '((#\f :control))) - -(set-key `(com-forward-object ,*numeric-argument-marker*) - 'movement-table - '((:right))) - -(defun transpose-words (mark) - (let (bw1 bw2 ew1 ew2) - (backward-word mark) - (setf bw1 (offset mark)) - (forward-word mark) - (setf ew1 (offset mark)) - (forward-word mark) - (when (= (offset mark) ew1) - ;; this is emacs' message in the minibuffer - (error "Don't have two things to transpose")) - (setf ew2 (offset mark)) - (backward-word mark) - (setf bw2 (offset mark)) - (let ((w2 (buffer-sequence (buffer mark) bw2 ew2)) - (w1 (buffer-sequence (buffer mark) bw1 ew1))) - (delete-word mark) - (insert-sequence mark w1) - (backward-word mark) - (backward-word mark) - (delete-word mark) - (insert-sequence mark w2) - (forward-word mark)))) - -(define-command (com-transpose-words :name t :command-table editing-table) () - (transpose-words (point (current-window)))) - -(set-key 'com-transpose-words - 'editing-table - '((#\t :meta))) - -(defun transpose-lines (mark) - (beginning-of-line mark) - (unless (beginning-of-buffer-p mark) - (previous-line mark)) - (let* ((bol (offset mark)) - (eol (progn (end-of-line mark) - (offset mark))) - (line (buffer-sequence (buffer mark) bol eol))) - (delete-region bol mark) - ;; Remove newline at end of line as well. - (unless (end-of-buffer-p mark) - (delete-range mark)) - ;; If the current line is at the end of the buffer, we want to - ;; be able to insert past it, so we need to get an extra line - ;; at the end. - (end-of-line mark) - (when (end-of-buffer-p mark) - (insert-object mark #\Newline)) - (next-line mark 0) - (insert-sequence mark line) - (insert-object mark #\Newline))) - -(define-command (com-transpose-lines :name t :command-table editing-table) () - (transpose-lines (point (current-window)))) - -(set-key 'com-transpose-lines - 'editing-table - '((#\x :control) (#\t :control))) - -(define-command (com-previous-line :name t :command-table movement-table) - ((numarg 'integer :prompt "How many lines?")) - (let* ((window (current-window)) - (point (point window))) - (unless (or (eq (previous-command window) 'com-previous-line) - (eq (previous-command window) 'com-next-line)) - (setf (slot-value window 'goal-column) (column-number point))) - (if (plusp numarg) - (previous-line point (slot-value window 'goal-column) numarg) - (next-line point (slot-value window 'goal-column) (- numarg))))) - -(set-key `(com-previous-line ,*numeric-argument-marker*) - 'movement-table - '((#\p :control))) - -(set-key `(com-previous-line ,*numeric-argument-marker*) - 'movement-table - '((:up))) - -(define-command (com-next-line :name t :command-table movement-table) - ((numarg 'integer :prompt "How many lines?")) - (let* ((window (current-window)) - (point (point window))) - (unless (or (eq (previous-command window) 'com-previous-line) - (eq (previous-command window) 'com-next-line)) - (setf (slot-value window 'goal-column) (column-number point))) - (if (plusp numarg) - (next-line point (slot-value window 'goal-column) numarg) - (previous-line point (slot-value window 'goal-column) (- numarg))))) - -(set-key `(com-next-line ,*numeric-argument-marker*) - 'movement-table - '((#\n :control))) - -(set-key `(com-next-line ,*numeric-argument-marker*) - 'movement-table - '((:down))) - -(define-command (com-open-line :name t :command-table editing-table) - ((numarg 'integer :prompt "How many lines?")) - (open-line (point (current-window)) numarg)) - -(set-key `(com-open-line ,*numeric-argument-marker*) - 'editing-table - '((#\o :control))) - -(defun kill-line (mark &optional (count 1) (whole-lines-p nil) (concatenate-p nil)) - (let ((start (offset mark))) - (cond ((= 0 count) - (beginning-of-line mark)) - ((< count 0) - (loop repeat (- count) - until (beginning-of-buffer-p mark) - do (beginning-of-line mark) - until (beginning-of-buffer-p mark) - do (backward-object mark))) - ((or whole-lines-p (> count 1)) - (loop repeat count - until (end-of-buffer-p mark) - do (end-of-line mark) - until (end-of-buffer-p mark) - do (forward-object mark))) - (t - (cond ((end-of-buffer-p mark) nil) - ((end-of-line-p mark)(forward-object mark)) - (t (end-of-line mark))))) - (unless (mark= mark start) - (if concatenate-p - (kill-ring-concatenating-push *kill-ring* - (region-to-sequence start mark)) - (kill-ring-standard-push *kill-ring* - (region-to-sequence start mark))) - (delete-region start mark)))) - -(define-command (com-kill-line :name t :command-table deletion-table) - ((numarg 'integer :prompt "Kill how many lines?") - (numargp 'boolean :prompt "Kill entire lines?")) - (let* ((pane (current-window)) - (point (point pane)) - (concatenate-p (eq (previous-command pane) 'com-kill-line))) - (kill-line point numarg numargp concatenate-p))) - -(set-key `(com-kill-line ,*numeric-argument-marker* ,*numeric-argument-p*) - 'deletion-table - '((#\k :control))) - -(define-command (com-forward-word :name t :command-table movement-table) - ((count 'integer :prompt "Number of words")) - (if (plusp count) - (forward-word (point (current-window)) count) - (backward-word (point (current-window)) (- count)))) - -(set-key `(com-forward-word ,*numeric-argument-marker*) - 'movement-table - '((#\f :meta))) - -(set-key `(com-forward-word ,*numeric-argument-marker*) - 'movement-table - '((:right :control))) - -(define-command (com-backward-word :name t :command-table movement-table) - ((count 'integer :prompt "Number of words")) - (backward-word (point (current-window)) count)) - -(set-key `(com-backward-word ,*numeric-argument-marker*) - 'movement-table - '((#\b :meta))) - -(set-key `(com-backward-word ,*numeric-argument-marker*) - 'movement-table - '((:left :control))) - -(define-command (com-delete-word :name t :command-table deletion-table) - ((count 'integer :prompt "Number of words")) - (delete-word (point (current-window)) count)) - -(defun kill-word (mark &optional (count 1) (concatenate-p nil)) - (let ((start (offset mark))) - (if (plusp count) - (loop repeat count - until (end-of-buffer-p mark) - do (forward-word mark)) - (loop repeat (- count) - until (beginning-of-buffer-p mark) - do (backward-word mark))) - (unless (mark= mark start) - (if concatenate-p - (if (plusp count) - (kill-ring-concatenating-push *kill-ring* - (region-to-sequence start mark)) - (kill-ring-reverse-concatenating-push *kill-ring* - (region-to-sequence start mark))) - (kill-ring-standard-push *kill-ring* - (region-to-sequence start mark))) - (delete-region start mark)))) - -(define-command (com-kill-word :name t :command-table deletion-table) - ((count 'integer :prompt "Number of words")) - (let* ((pane (current-window)) - (point (point pane)) - (concatenate-p (eq (previous-command pane) 'com-kill-word))) - (kill-word point count concatenate-p))) - -(set-key `(com-kill-word ,*numeric-argument-marker*) - 'deletion-table - '((#\d :meta))) - -(define-command (com-backward-kill-word :name t :command-table deletion-table) - ((count 'integer :prompt "Number of words")) - (let* ((pane (current-window)) - (point (point pane)) - (concatenate-p (eq (previous-command pane) 'com-backward-kill-word))) - (kill-word point (- count) concatenate-p))) - -(set-key `(com-backward-kill-word ,*numeric-argument-marker*) - 'deletion-table - '((#\Backspace :meta))) - -(define-command (com-mark-word :name t :command-table marking-table) - ((count 'integer :prompt "Number of words")) - (let* ((pane (current-window)) - (point (point pane)) - (mark (mark pane))) - (unless (eq (previous-command pane) 'com-mark-word) - (setf (offset mark) (offset point))) - (if (plusp count) - (forward-word mark count) - (backward-word mark (- count))))) - -(set-key `(com-mark-word ,*numeric-argument-marker*) - 'marking-table - '((#\@ :meta :shift))) - -(define-command (com-backward-delete-word :name t :command-table deletion-table) - ((count 'integer :prompt "Number of words")) - (backward-delete-word (point (current-window)) count)) - -(define-command (com-upcase-region :name t :command-table case-table) () - (let ((cw (current-window))) - (upcase-region (mark cw) (point cw)))) - -(define-command (com-downcase-region :name t :command-table case-table) () - (let ((cw (current-window))) - (downcase-region (mark cw) (point cw)))) - -(define-command (com-capitalize-region :name t :command-table case-table) () - (let ((cw (current-window))) - (capitalize-region (mark cw) (point cw)))) - -(define-command (com-upcase-word :name t :command-table case-table) () - (upcase-word (point (current-window)))) - -(set-key 'com-upcase-word - 'case-table - '((#\u :meta))) - -(define-command (com-downcase-word :name t :command-table case-table) () - (downcase-word (point (current-window)))) - -(set-key 'com-downcase-word - 'case-table - '((#\l :meta))) - -(define-command (com-capitalize-word :name t :command-table case-table) () - (capitalize-word (point (current-window)))) - -(set-key 'com-capitalize-word - 'case-table - '((#\c :meta))) - -(define-command (com-tabify-region :name t :command-table editing-table) () - (let ((pane (current-window))) - (tabify-region - (mark pane) (point pane) (tab-space-count (stream-default-view pane))))) - -(define-command (com-untabify-region :name t :command-table editing-table) () - (let ((pane (current-window))) - (untabify-region - (mark pane) (point pane) (tab-space-count (stream-default-view pane))))) - -(defun indent-current-line (pane point) - (let* ((buffer (buffer pane)) - (view (stream-default-view pane)) - (tab-space-count (tab-space-count view)) - (indentation (syntax-line-indentation point - tab-space-count - (syntax buffer)))) - (indent-line point indentation (and (indent-tabs-mode buffer) - tab-space-count)))) - -(define-command (com-indent-line :name t :command-table indent-table) () - (let* ((pane (current-window)) - (point (point pane))) - (indent-current-line pane point))) - -(set-key 'com-indent-line - 'indent-table - '((#\Tab))) - -(set-key 'com-indent-line - 'indent-table - '((#\i :control))) - -(define-command (com-newline-and-indent :name t :command-table indent-table) () - (let* ((pane (current-window)) - (point (point pane))) - (insert-object point #\Newline) - (indent-current-line pane point))) - -(set-key 'com-newline-and-indent - 'indent-table - '((#\j :control))) - -(define-command (com-delete-indentation :name t :command-table indent-table) () - (delete-indentation (point (current-window)))) - -(set-key 'com-delete-indentation - 'indent-table - '((#\^ :shift :meta))) - -(define-command (com-auto-fill-mode :name t :command-table fill-table) () - (let ((pane (current-window))) - (setf (auto-fill-mode pane) (not (auto-fill-mode pane))))) - -(define-command (com-fill-paragraph :name t :command-table fill-table) () - (let* ((pane (current-window)) - (buffer (buffer pane)) - (syntax (syntax buffer)) - (point (point pane)) - (begin-mark (clone-mark point)) - (end-mark (clone-mark point))) - (unless (eql (object-before begin-mark) #\Newline) - (backward-paragraph begin-mark syntax)) - (unless (eql (object-after end-mark) #\Newline) - (forward-paragraph end-mark syntax)) - (do-buffer-region (object offset buffer - (offset begin-mark) (offset end-mark)) - (when (eql object #\Newline) - (setf object #\Space))) - (let ((point-backup (clone-mark point))) - (setf (offset point) (offset end-mark)) - (possibly-fill-line) - (setf (offset point) (offset point-backup))))) - -(set-key 'com-fill-paragraph - 'fill-table - '((#\q :meta))) - -(defun filename-completer (so-far mode) - (flet ((remove-trail (s) - (subseq s 0 (let ((pos (position #\/ s :from-end t))) - (if pos (1+ pos) 0))))) - (let* ((directory-prefix - (if (and (plusp (length so-far)) (eql (aref so-far 0) #\/)) - "" - (namestring #+sbcl *default-pathname-defaults* - #+cmu (ext:default-directory) - #-(or sbcl cmu) *default-pathname-defaults*))) - (full-so-far (concatenate 'string directory-prefix so-far)) - (pathnames - (loop with length = (length full-so-far) - and wildcard = (concatenate 'string (remove-trail so-far) "*.*") - for path in - #+(or sbcl cmu lispworks) (directory wildcard) - #+openmcl (directory wildcard :directories t) - #+allegro (directory wildcard :directories-are-files nil) - #+cormanlisp (nconc (directory wildcard) - (cl::directory-subdirs dirname)) - #-(or sbcl cmu lispworks openmcl allegro cormanlisp) - (directory wildcard) - when (let ((mismatch (mismatch (namestring path) full-so-far))) - (or (null mismatch) (= mismatch length))) - collect path)) - (strings (mapcar #'namestring pathnames)) - (first-string (car strings)) - (length-common-prefix nil) - (completed-string nil) - (full-completed-string nil)) - (unless (null pathnames) - (setf length-common-prefix - (loop with length = (length first-string) - for string in (cdr strings) - do (setf length (min length (or (mismatch string first-string) length))) - finally (return length)))) - (unless (null pathnames) - (setf completed-string - (subseq first-string (length directory-prefix) - (if (null (cdr pathnames)) nil length-common-prefix))) - (setf full-completed-string - (concatenate 'string directory-prefix completed-string))) - (case mode - ((:complete-limited :complete-maximal) - (cond ((null pathnames) - (values so-far nil nil 0 nil)) - ((null (cdr pathnames)) - (values completed-string t (car pathnames) 1 nil)) - (t - (values completed-string nil nil (length pathnames) nil)))) - (:complete - (cond ((null pathnames) - (values so-far t so-far 1 nil)) - ((null (cdr pathnames)) - (values completed-string t (car pathnames) 1 nil)) - ((find full-completed-string strings :test #'string-equal) - (let ((pos (position full-completed-string strings :test #'string-equal))) - (values completed-string - t (elt pathnames pos) (length pathnames) nil))) +(define-command (com-full-redisplay :name t :command-table base-table) () + (full-redisplay (current-window))) + +(set-key 'com-full-redisplay + 'base-table + '((#\l :control))) + +(defun load-file (file-name) + (cond ((directory-pathname-p file-name) + (display-message "~A is a directory name." file-name) + (beep)) + (t + (cond ((probe-file file-name) + (load file-name)) (t - (values completed-string nil nil (length pathnames) nil)))) - (:possibilities - (values nil nil nil (length pathnames) - (loop with length = (length directory-prefix) - for name in pathnames - collect (list (subseq (namestring name) length nil) - name)))))))) - -(define-presentation-method present (object (type pathname) - stream (view climacs-textual-view) &key) - (princ (namestring object) stream)) - -(define-presentation-method accept ((type pathname) stream (view climacs-textual-view) - &key (default nil defaultp) (default-type type)) - (multiple-value-bind (pathname success string) - (complete-input stream - #'filename-completer - :allow-any-input t) - (cond (success - (values pathname type)) - ((and (zerop (length string)) - defaultp) - (values default default-type)) - (t (values string 'string))))) - -(defun filepath-filename (pathname) - (if (null (pathname-type pathname)) - (pathname-name pathname) - (concatenate 'string (pathname-name pathname) - "." (pathname-type pathname)))) - -(defun syntax-class-name-for-filepath (filepath) - (or (climacs-syntax::syntax-description-class-name - (find (or (pathname-type filepath) - (pathname-name filepath)) - climacs-syntax::*syntaxes* - :test (lambda (x y) - (member x y :test #'string-equal)) - :key #'climacs-syntax::syntax-description-pathname-types)) - 'basic-syntax)) - -;; Adapted from cl-fad/PCL -(defun directory-pathname-p (pathspec) - "Returns NIL if PATHSPEC does not designate a directory." - (let ((name (pathname-name pathspec)) - (type (pathname-type pathspec))) - (and (or (null name) (eql name :unspecific)) - (or (null type) (eql type :unspecific))))) + (display-message "No such file: ~A" file-name) + (beep)))))) + +(define-command (com-load-file :name t :command-table base-table) () + (let ((filepath (accept 'pathname :prompt "Load File"))) + (load-file filepath))) + +(set-key 'com-load-file + 'base-table + '((#\c :control) (#\l :control))) + +(loop for code from (char-code #\Space) to (char-code #\~) + do (set-key `(com-self-insert ,*numeric-argument-marker*) + 'self-insert-table + (list (list (code-char code))))) + +(set-key `(com-self-insert ,*numeric-argument-marker*) + 'self-insert-table + '((#\Newline))) + +;;;;;;;;;;;;;;;;;;; +;;; Pane commands (defun make-buffer (&optional name) (let ((buffer (make-instance 'climacs-buffer))) @@ -903,124 +294,6 @@ (push buffer (buffers *application-frame*)) buffer)) -(defun find-file (filepath) - (cond ((null filepath) - (display-message "No file name given.") - (beep)) - ((directory-pathname-p filepath) - (display-message "~A is a directory name." filepath) - (beep)) - (t - (let ((existing-buffer (find filepath (buffers *application-frame*) - :key #'filepath :test #'equal))) - (if existing-buffer - (switch-to-buffer existing-buffer) - (let ((buffer (make-buffer)) - (pane (current-window))) - (setf (offset (point (buffer pane))) (offset (point pane))) - (setf (buffer (current-window)) buffer) - (setf (syntax buffer) - (make-instance (syntax-class-name-for-filepath filepath) - :buffer (buffer (point pane)))) - ;; Don't want to create the file if it doesn't exist. - (when (probe-file filepath) - (with-open-file (stream filepath :direction :input) - (input-from-stream stream buffer 0))) - (setf (filepath buffer) filepath - (name buffer) (filepath-filename filepath) - (needs-saving buffer) nil) - (beginning-of-buffer (point pane)) - ;; this one is needed so that the buffer modification protocol - ;; resets the low and high marks after redisplay - (redisplay-frame-panes *application-frame*) - buffer)))))) - -(define-command (com-find-file :name t :command-table buffer-table) () - (let* ((filepath (accept 'pathname :prompt "Find File"))) - (find-file filepath))) - -(set-key 'com-find-file - 'buffer-table - '((#\x :control) (#\f :control))) - -(defun find-file-read-only (filepath) - (cond ((null filepath) - (display-message "No file name given.") - (beep)) - ((directory-pathname-p filepath) - (display-message "~A is a directory name." filepath) - (beep)) - (t - (let ((existing-buffer (find filepath (buffers *application-frame*) - :key #'filepath :test #'equal))) - (if (and existing-buffer (read-only-p existing-buffer)) - (switch-to-buffer existing-buffer) - (if (probe-file filepath) - (let ((buffer (make-buffer)) - (pane (current-window))) - (setf (offset (point (buffer pane))) (offset (point pane))) - (setf (buffer (current-window)) buffer) - (setf (syntax buffer) - (make-instance (syntax-class-name-for-filepath filepath) - :buffer (buffer (point pane)))) - (with-open-file (stream filepath :direction :input) - (input-from-stream stream buffer 0)) - (setf (filepath buffer) filepath - (name buffer) (filepath-filename filepath) - (needs-saving buffer) nil - (read-only-p buffer) t) - (beginning-of-buffer (point pane)) - ;; this one is needed so that the buffer modification protocol - ;; resets the low and high marks after redisplay - (redisplay-frame-panes *application-frame*) - buffer) - (progn - (display-message "No such file: ~A" filepath) - (beep) - nil))))))) - -(define-command (com-find-file-read-only :name t :command-table buffer-table) () - (let ((filepath (accept 'pathname :Prompt "Find file read only"))) - (find-file-read-only filepath))) - -(set-key 'com-find-file-read-only - 'buffer-table - '((#\x :control) (#\r :control))) - -(define-command (com-read-only :name t :command-table buffer-table) () - (let ((buffer (buffer (current-window)))) - (setf (read-only-p buffer) (not (read-only-p buffer))))) - -(set-key 'com-read-only - 'buffer-table - '((#\x :control) (#\q :control))) - -(defun set-visited-file-name (filename buffer) - (setf (filepath buffer) filename - (name buffer) (filepath-filename filename) - (needs-saving buffer) t)) - -(define-command (com-set-visited-file-name :name t :command-table buffer-table) () - (let ((filename (accept 'pathname :prompt "New file name"))) - (set-visited-file-name filename (buffer (current-window))))) - -(define-command (com-insert-file :name t :command-table buffer-table) () - (let ((filename (accept 'pathname :prompt "Insert File")) - (pane (current-window))) - (when (probe-file filename) - (setf (mark pane) (clone-mark (point pane) :left)) - (with-open-file (stream filename :direction :input) - (input-from-stream stream - (buffer pane) - (offset (point pane)))) - (psetf (offset (mark pane)) (offset (point pane)) - (offset (point pane)) (offset (mark pane)))) - (redisplay-frame-panes *application-frame*))) - -(set-key 'com-insert-file - 'buffer-table - '((#\x :control) (#\i :control))) - (defgeneric erase-buffer (buffer)) (defmethod erase-buffer ((buffer string)) @@ -1035,93 +308,6 @@ (end-of-buffer point) (delete-region mark point))) -(define-command (com-revert-buffer :name t :command-table buffer-table) () - (let* ((pane (current-window)) - (buffer (buffer pane)) - (filepath (filepath buffer)) - (save (offset (point pane)))) - (when (accept 'boolean :prompt (format nil "Revert buffer from file ~A?" - (filepath buffer))) - (cond ((directory-pathname-p filepath) - (display-message "~A is a directory name." filepath) - (beep)) - ((probe-file filepath) - (erase-buffer buffer) - (with-open-file (stream filepath :direction :input) - (input-from-stream stream buffer 0)) - (setf (offset (point pane)) - (min (size buffer) save))) - (t - (display-message "No file ~A" filepath) - (beep)))))) - -(defun save-buffer (buffer) - (let ((filepath (or (filepath buffer) - (accept 'pathname :prompt "Save Buffer to File")))) - (cond - ((directory-pathname-p filepath) - (display-message "~A is a directory." filepath) - (beep)) - (t - (when (probe-file filepath) - (let ((backup-name (pathname-name filepath)) - (backup-type (concatenate 'string (pathname-type filepath) "~"))) - (rename-file filepath (make-pathname :name backup-name - :type backup-type)))) - (with-open-file (stream filepath :direction :output :if-exists :supersede) - (output-to-stream stream buffer 0 (size buffer))) - (setf (filepath buffer) filepath - (name buffer) (filepath-filename filepath)) - (display-message "Wrote: ~a" (filepath buffer)) - (setf (needs-saving buffer) nil))))) - -(define-command (com-save-buffer :name t :command-table buffer-table) () - (let ((buffer (buffer (current-window)))) - (if (or (null (filepath buffer)) - (needs-saving buffer)) - (save-buffer buffer) - (display-message "No changes need to be saved from ~a" (name buffer))))) - -(set-key 'com-save-buffer - 'buffer-table - '((#\x :control) (#\s :control))) - -(defmethod frame-exit :around ((frame climacs)) - (loop for buffer in (buffers frame) - when (and (needs-saving buffer) - (filepath buffer) - (handler-case (accept 'boolean - :prompt (format nil "Save buffer: ~a ?" (name buffer))) - (error () (progn (beep) - (display-message "Invalid answer") - (return-from frame-exit nil))))) - do (save-buffer buffer)) - (when (or (notany #'(lambda (buffer) (and (needs-saving buffer) (filepath buffer))) - (buffers frame)) - (handler-case (accept 'boolean :prompt "Modified buffers exist. Quit anyway?") - (error () (progn (beep) - (display-message "Invalid answer") - (return-from frame-exit nil))))) - (call-next-method))) - -(define-command (com-write-buffer :name t :command-table buffer-table) () - (let ((filepath (accept 'pathname :prompt "Write Buffer to File")) - (buffer (buffer (current-window)))) - (cond - ((directory-pathname-p filepath) - (display-message "~A is a directory name." filepath)) - (t - (with-open-file (stream filepath :direction :output :if-exists :supersede) - (output-to-stream stream buffer 0 (size buffer))) - (setf (filepath buffer) filepath - (name buffer) (filepath-filename filepath) - (needs-saving buffer) nil) - (display-message "Wrote: ~a" (filepath buffer)))))) - -(set-key 'com-write-buffer - 'buffer-table - '((#\x :control) (#\w :control))) - (define-presentation-method present (object (type buffer) stream (view textual-view) @@ -1227,1497 +413,3 @@ (set-key 'com-kill-buffer 'pane-table '((#\x :control) (#\k))) - -(define-command (com-full-redisplay :name t :command-table base-table) () - (full-redisplay (current-window))) - -(set-key 'com-full-redisplay - 'base-table - '((#\l :control))) - -(defun load-file (file-name) - (cond ((directory-pathname-p file-name) - (display-message "~A is a directory name." file-name) - (beep)) - (t - (cond ((probe-file file-name) - (load file-name)) - (t - (display-message "No such file: ~A" file-name) - (beep)))))) - -(define-command (com-load-file :name t :command-table base-table) () - (let ((filepath (accept 'pathname :prompt "Load File"))) - (load-file filepath))) - -(set-key 'com-load-file - 'base-table - '((#\c :control) (#\l :control))) - -(define-command (com-beginning-of-buffer :name t :command-table movement-table) () - (beginning-of-buffer (point (current-window)))) - -(set-key 'com-beginning-of-buffer - 'movement-table - '((#\< :shift :meta))) - -(set-key 'com-beginning-of-buffer - 'movement-table - '((:home :control))) - -(define-command (com-page-down :name t :command-table movement-table) () - (let ((pane (current-window))) - (page-down pane))) - -(set-key 'com-page-down - 'movement-table - '((#\v :control))) - -(set-key 'com-page-down - 'movement-table - '((:next))) - -(define-command (com-page-up :name t :command-table movement-table) () - (let ((pane (current-window))) - (page-up pane))) - -(set-key 'com-page-up - 'movement-table - '((#\v :meta))) - -(set-key 'com-page-up - 'movement-table - '((:prior))) - -(define-command (com-end-of-buffer :name t :command-table movement-table) () - (end-of-buffer (point (current-window)))) - -(set-key 'com-end-of-buffer - 'movement-table - '((#\> :shift :meta))) - -(set-key 'com-end-of-buffer - 'movement-table - '((:end :control))) - -(define-command (com-mark-whole-buffer :name t :command-table marking-table) () - (beginning-of-buffer (point (current-window))) - (end-of-buffer (mark (current-window)))) - -(set-key 'com-mark-whole-buffer - 'marking-table - '((#\x :control) (#\h))) - -(defun back-to-indentation (mark) - (beginning-of-line mark) - (loop until (end-of-line-p mark) - while (whitespacep (object-after mark)) - do (forward-object mark))) - -(define-command (com-back-to-indentation :name t :command-table movement-table) () - (back-to-indentation (point (current-window)))) - -(set-key 'com-back-to-indentation - 'movement-table - '((#\m :meta))) - -(defun delete-horizontal-space (mark &optional (backward-only-p nil)) - (let ((mark2 (clone-mark mark))) - (loop until (beginning-of-line-p mark) - while (whitespacep (object-before mark)) - do (backward-object mark)) - (unless backward-only-p - (loop until (end-of-line-p mark2) - while (whitespacep (object-after mark2)) - do (forward-object mark2))) - (delete-region mark mark2))) - -(define-command (com-delete-horizontal-space :name t :command-table deletion-table) - ((backward-only-p - 'boolean :prompt "Delete backwards only?")) - (delete-horizontal-space (point (current-window)) backward-only-p)) - -(set-key `(com-delete-horizontal-space ,*numeric-argument-p*) - 'deletion-table - '((#\\ :meta))) - -(defun just-one-space (mark count) - (let (offset) - (loop until (beginning-of-line-p mark) - while (whitespacep (object-before mark)) - do (backward-object mark)) - (loop until (end-of-line-p mark) - while (whitespacep (object-after mark)) - repeat count do (forward-object mark) - finally (setf offset (offset mark))) - (loop until (end-of-line-p mark) - while (whitespacep (object-after mark)) - do (forward-object mark)) - (delete-region offset mark))) - -(define-command (com-just-one-space :name t :command-table deletion-table) - ((count 'integer :prompt "Number of spaces")) - (just-one-space (point (current-window)) count)) - -(set-key `(com-just-one-space ,*numeric-argument-marker*) - 'deletion-table - '((#\Space :meta))) - -(defun goto-position (mark pos) - (setf (offset mark) pos)) - -(define-command (com-goto-position :name t :command-table movement-table) () - (goto-position - (point (current-window)) - (handler-case (accept 'integer :prompt "Goto Position") - (error () (progn (beep) - (display-message "Not a valid position") - (return-from com-goto-position nil)))))) - -(defun goto-line (mark line-number) - (loop with m = (clone-mark (low-mark (buffer mark)) - :right) - initially (beginning-of-buffer m) - do (end-of-line m) - until (end-of-buffer-p m) - repeat (1- line-number) - do (incf (offset m)) - (end-of-line m) - finally (beginning-of-line m) - (setf (offset mark) (offset m)))) - -(define-command (com-goto-line :name t :command-table movement-table) () - (goto-line (point (current-window)) - (handler-case (accept 'integer :prompt "Goto Line") - (error () (progn (beep) - (display-message "Not a valid line number") - (return-from com-goto-line nil)))))) - -(define-command (com-browse-url :name t :command-table base-table) () - (let ((url (accept 'url :prompt "Browse URL"))) - #+ (and sbcl darwin) - (sb-ext:run-program "/usr/bin/open" `(,url) :wait nil) - #+ (and openmcl darwin) - (ccl:run-program "/usr/bin/open" `(,url) :wait nil))) - -(define-command (com-set-mark :name t :command-table marking-table) () - (let ((pane (current-window))) - (setf (mark pane) (clone-mark (point pane))))) - -(set-key 'com-set-mark - 'marking-table - '((#\Space :control))) - -(define-command (com-exchange-point-and-mark :name t :command-table marking-table) () - (let ((pane (current-window))) - (psetf (offset (mark pane)) (offset (point pane)) - (offset (point pane)) (offset (mark pane))))) - -(set-key 'com-exchange-point-and-mark - 'marking-table - '((#\x :control) (#\x :control))) - -(defgeneric set-syntax (buffer syntax)) - -(defmethod set-syntax ((buffer climacs-buffer) (syntax syntax)) - (setf (syntax buffer) syntax)) - -;;; FIXME: This :around method is probably not going to remain here -;;; for ever; it is a symptom of level mixing, I think. See also the -;;; similar method on (SETF BUFFER). -- CSR, 2005-10-31. -(defmethod (setf syntax) :around (syntax (buffer climacs-buffer)) - (call-next-method) - ;; FIXME: we need this because some clients (e.g. the tablature - ;; editor) use climacs buffers without a gui, for off-line (e.g. Web - ;; backend) processing. The problem here is that (setf syntax) - ;; /should/ have no GUI effects whatsoever. So maybe the right - ;; answer would instead be to find the active pane's buffer in the - ;; top-level loop? That might need to be pushed into ESA. - (when clim:*application-frame* - (let ((pane (current-window))) - (assert (eq (buffer pane) buffer)) - (note-pane-syntax-changed pane syntax)))) - -;;; FIXME - what should this specialise on? -(defmethod set-syntax ((buffer climacs-buffer) syntax) - (set-syntax buffer (make-instance syntax :buffer buffer))) - -(defmethod set-syntax ((buffer climacs-buffer) (syntax string)) - (let ((syntax-class (syntax-from-name syntax))) - (cond (syntax-class - (set-syntax buffer (make-instance syntax-class - :buffer buffer))) - (t - (beep) - (display-message "No such syntax: ~A." syntax))))) - -(define-command (com-set-syntax :name t :command-table buffer-table) () - (let* ((pane (current-window)) - (buffer (buffer pane))) - (set-syntax buffer (accept 'syntax :prompt "Set Syntax")))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; -;;; Commands for splitting windows - -(defun replace-constellation (constellation additional-constellation vertical-p) - (let* ((parent (sheet-parent constellation)) - (children (sheet-children parent)) - (first (first children)) - (second (second children)) - (third (third children)) - (adjust (make-pane 'clim-extensions:box-adjuster-gadget))) - (assert (member constellation children)) - (sheet-disown-child parent constellation) - (let ((new (if vertical-p - (vertically () - constellation adjust additional-constellation) - (horizontally () - constellation adjust additional-constellation)))) - (sheet-adopt-child parent new) - (reorder-sheets parent - (if (eq constellation first) - (if third - (list new second third) - (list new second)) - (if third - (list first second new) - (list first new))))))) - -(defun find-parent (sheet) - (loop for parent = (sheet-parent sheet) - then (sheet-parent parent) - until (typep parent 'vrack-pane) - finally (return parent))) - -(defclass typeout-pane (application-pane esa-pane-mixin) ()) - -(defun make-typeout-constellation (&optional label) - (let* ((typeout-pane - (make-pane 'typeout-pane :width 900 :height 400 :display-time nil)) - (label - (make-pane 'label-pane :label label)) - (vbox - (vertically () - (scrolling (:scroll-bar :vertical) typeout-pane) label))) - (values vbox typeout-pane))) - -(defun typeout-window (&optional (label "Typeout") (pane (current-window))) - (with-look-and-feel-realization - ((frame-manager *application-frame*) *application-frame*) - (multiple-value-bind (vbox new-pane) (make-typeout-constellation label) - (let* ((current-window pane) - (constellation-root (find-parent current-window))) - (push new-pane (windows *application-frame*)) - (other-window) - (replace-constellation constellation-root vbox t) - (full-redisplay current-window) - new-pane)))) - -(define-command (com-describe-bindings :name t :command-table help-table) - ((sort-by-keystrokes 'boolean :prompt "Sort by keystrokes?")) - (let* ((window (current-window)) - (buffer (buffer (current-window))) - (stream (typeout-window - (format nil "~10THelp: Describe Bindings for ~A" (name buffer)))) - (command-table (command-table window))) - (esa::describe-bindings stream command-table - (if sort-by-keystrokes - #'esa::sort-by-keystrokes - #'esa::sort-by-name)))) - -(set-key `(com-describe-bindings ,*numeric-argument-p*) 'help-table '((#\h :control) (#\b))) - -(defun make-pane-constellation (&optional (with-scrollbars *with-scrollbars*)) - "make a vbox containing a scroller pane as its first child and an -info pane as its second child. The scroller pane contains a viewport -which contains an extended pane. Return the vbox and the extended pane -as two values. -If with-scrollbars nil, omit the scroller." - (let* ((extended-pane - (make-pane 'extended-pane - :width 900 :height 400 - :name 'window - :end-of-line-action :scroll - :incremental-redisplay t - :display-function 'display-window - :command-table 'global-climacs-table)) - (vbox - (vertically () - (if with-scrollbars - (scrolling () - extended-pane) - extended-pane) - (make-pane 'climacs-info-pane - :master-pane extended-pane - :width 900)))) - (values vbox extended-pane))) - -(defun split-window (&optional (vertically-p nil) (pane (current-window))) - (with-look-and-feel-realization - ((frame-manager *application-frame*) *application-frame*) - (multiple-value-bind (vbox new-pane) (make-pane-constellation) - (let* ((current-window pane) - (constellation-root (find-parent current-window))) - (setf (offset (point (buffer current-window))) (offset (point current-window)) - (buffer new-pane) (buffer current-window) - (auto-fill-mode new-pane) (auto-fill-mode current-window) - (auto-fill-column new-pane) (auto-fill-column current-window)) - (push new-pane (windows *application-frame*)) - (setf *standard-output* new-pane) - (replace-constellation constellation-root vbox vertically-p) - (full-redisplay current-window) - (full-redisplay new-pane) - new-pane)))) - -(define-command (com-split-window-vertically :name t :command-table window-table) () - (split-window t)) - -(set-key 'com-split-window-vertically - 'window-table - '((#\x :control) (#\2))) - -(define-command (com-split-window-horizontally :name t :command-table window-table) () - (split-window)) - -(set-key 'com-split-window-horizontally - 'window-table - '((#\x :control) (#\3))) - -(defun other-window (&optional pane) - (if (and pane (find pane (windows *application-frame*))) - (setf (windows *application-frame*) - (append (list pane) - (remove pane (windows *application-frame*)))) - (setf (windows *application-frame*) - (append (cdr (windows *application-frame*)) - (list (car (windows *application-frame*)))))) - (setf *standard-output* (car (windows *application-frame*)))) - -(define-command (com-other-window :name t :command-table window-table) () - (other-window)) - -(set-key 'com-other-window - 'window-table - '((#\x :control) (#\o))) - -(defun click-to-offset (window x y) - (with-slots (top bot) window - (let ((new-x (floor x (stream-character-width window #\m))) - (new-y (floor y (stream-line-height window))) - (buffer (buffer window))) - (loop for scan from (offset top) - with lines = 0 - until (= scan (offset bot)) - until (= lines new-y) - when (eql (buffer-object buffer scan) #\Newline) - do (incf lines) - finally (loop for columns from 0 - until (= scan (offset bot)) - until (eql (buffer-object buffer scan) #\Newline) - until (= columns new-x) - do (incf scan)) - (return scan))))) - -(define-command (com-switch-to-this-window :name nil :command-table window-table) - ((window 'pane) (x 'integer) (y 'integer)) - (other-window window) - (when (typep window 'extended-pane) - (setf (offset (point window)) - (click-to-offset window x y)))) - -(define-presentation-to-command-translator blank-area-to-switch-to-this-window - (blank-area com-switch-to-this-window window-table :echo nil) - (window x y) - (list window x y)) - -(define-gesture-name :select-other :pointer-button (:right) :unique nil) - -(define-command (com-mouse-save :name nil :command-table window-table) - ((window 'pane) (x 'integer) (y 'integer)) - (when (and (typep window 'extended-pane) - (eq window (current-window))) - (setf (offset (mark window)) - (click-to-offset window x y)) - (com-exchange-point-and-mark) - (com-copy-region))) - -(define-presentation-to-command-translator blank-area-to-mouse-save - (blank-area com-mouse-save window-table :echo nil :gesture :select-other) - (window x y) - (list window x y)) - -(define-gesture-name :middle-button :pointer-button (:middle) :unique nil) - -(define-command (com-yank-here :name nil :command-table window-table) - ((window 'pane) (x 'integer) (y 'integer)) - (when (typep window 'extended-pane) - (other-window window) - (setf (offset (point window)) - (click-to-offset window x y)) - (com-yank))) - -(define-presentation-to-command-translator blank-area-to-yank-here - (blank-area com-yank-here window-table :echo nil :gesture :middle-button) - (window x y) - (list window x y)) - -(defun single-window () - (loop until (null (cdr (windows *application-frame*))) - do (rotatef (car (windows *application-frame*)) - (cadr (windows *application-frame*))) - (com-delete-window)) - (setf *standard-output* (car (windows *application-frame*)))) - -(define-command (com-single-window :name t :command-table window-table) () - (single-window)) - -(set-key 'com-single-window - 'window-table - '((#\x :control) (#\1))) - -(define-command (com-scroll-other-window :name t :command-table window-table) () - (let ((other-window (second (windows *application-frame*)))) - (when other-window - (page-down other-window)))) - -(set-key 'com-scroll-other-window - 'window-table - '((#\v :control :meta))) - -(define-command (com-scroll-other-window-up :name t :command-table window-table) () - (let ((other-window (second (windows *application-frame*)))) - (when other-window - (page-up other-window)))) - -(set-key 'com-scroll-other-window-up - 'window-table - '((#\V :control :meta :shift))) - -(defun delete-window (&optional (window (current-window))) - (unless (null (cdr (windows *application-frame*))) - (let* ((constellation (find-parent window)) - (box (sheet-parent constellation)) - (box-children (sheet-children box)) - (other (if (eq constellation (first box-children)) - (third box-children) - (first box-children))) - (parent (sheet-parent box)) - (children (sheet-children parent)) - (first (first children)) - (second (second children)) - (third (third children))) - (setf (windows *application-frame*) - (remove window (windows *application-frame*))) - (setf *standard-output* (car (windows *application-frame*))) - (sheet-disown-child box other) - (sheet-disown-child parent box) - (sheet-adopt-child parent other) - (reorder-sheets parent (if (eq box first) - (if third - (list other second third) - (list other second)) - (if third - (list first second other) - (list first other))))))) - -(define-command (com-delete-window :name t :command-table window-table) () - (delete-window)) - -(set-key 'com-delete-window - 'window-table - '((#\x :control) (#\0))) - -;;;;;;;;;;;;;;;;;;;; -;; Kill ring commands - -;; Copies an element from a kill-ring to a buffer at the given offset -(define-command (com-yank :name t :command-table editing-table) () - (insert-sequence (point (current-window)) (kill-ring-yank *kill-ring*))) - -(set-key 'com-yank - 'editing-table - '((#\y :control))) - -;; Destructively cut a given buffer region into the kill-ring -(define-command (com-kill-region :name t :command-table editing-table) () - (let ((pane (current-window))) - (kill-ring-standard-push - *kill-ring* (region-to-sequence (mark pane) (point pane))) - (delete-region (mark pane) (point pane)))) - -(set-key 'com-kill-region - 'editing-table - '((#\w :control))) - -;; Non destructively copies buffer region to the kill ring -(define-command (com-copy-region :name t :command-table marking-table) () - (let ((pane (current-window))) - (kill-ring-standard-push *kill-ring* (region-to-sequence (point pane) (mark pane))))) - -(set-key 'com-copy-region - 'marking-table - '((#\w :meta))) - -(define-command (com-rotate-yank :name t :command-table editing-table) () - (let* ((pane (current-window)) - (point (point pane)) - (last-yank (kill-ring-yank *kill-ring*))) - (if (eq (previous-command pane) - 'com-rotate-yank) - (progn - (delete-range point (* -1 (length last-yank))) - (rotate-yank-position *kill-ring*))) - (insert-sequence point (kill-ring-yank *kill-ring*)))) - -(set-key 'com-rotate-yank - 'editing-table - '((#\y :meta))) - -(define-command (com-resize-kill-ring :name t :command-table editing-table) () - (let ((size (handler-case (accept 'integer :prompt "New kill ring size") - (error () (progn (beep) - (display-message "Not a valid kill ring size") - (return-from com-resize-kill-ring nil)))))) - (setf (kill-ring-max-size *kill-ring*) size))) - -(define-command (com-append-next-kill :name t :command-table editing-table) () - (setf (append-next-p *kill-ring*) t)) - -(set-key 'com-append-next-kill - 'editing-table - '((#\w :control :meta))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; -;;; Incremental search - -(make-command-table 'isearch-climacs-table :errorp nil) - -(defun isearch-command-loop (pane forwardp) - (let ((point (point pane))) - (unless (endp (isearch-states pane)) - (setf (isearch-previous-string pane) - (search-string (first (isearch-states pane))))) - (setf (isearch-mode pane) t) - (setf (isearch-states pane) - (list (make-instance 'isearch-state - :search-string "" - :search-mark (clone-mark point) - :search-forward-p forwardp - :search-success-p t))) - (simple-command-loop 'isearch-climacs-table - (isearch-mode pane) - ((setf (isearch-mode pane) nil))))) - -(defun isearch-from-mark (pane mark string forwardp) - (flet ((object-equal (x y) - (if (characterp x) - (and (characterp y) (char-equal x y)) - (eql x y)))) - (let* ((point (point pane)) - (mark2 (clone-mark mark)) - (success (funcall (if forwardp #'search-forward #'search-backward) - mark2 - string - :test #'object-equal))) - (when success - (setf (offset point) (offset mark2) - (offset mark) (if forwardp - (- (offset mark2) (length string)) - (+ (offset mark2) (length string))))) - (display-message "~:[Failing ~;~]Isearch~:[ backward~;~]: ~A" - success forwardp string) - (push (make-instance 'isearch-state - :search-string string - :search-mark mark - :search-forward-p forwardp - :search-success-p success) - (isearch-states pane)) - (unless success - (beep))))) - -(define-command (com-isearch-forward :name t :command-table search-table) () - (display-message "Isearch: ") - (isearch-command-loop (current-window) t)) - -(set-key 'com-isearch-forward - 'search-table - '((#\s :control))) - -(define-command (com-isearch-backward :name t :command-table search-table) () - (display-message "Isearch backward: ") - (isearch-command-loop (current-window) nil)) - -(set-key 'com-isearch-backward - 'search-table - '((#\r :control))) - -(define-command (com-isearch-append-char :name t :command-table isearch-climacs-table) () - (let* ((pane (current-window)) - (states (isearch-states pane)) - (string (concatenate 'string - (search-string (first states)) - (string *current-gesture*))) - (mark (clone-mark (search-mark (first states)))) - (forwardp (search-forward-p (first states)))) - (unless forwardp - (incf (offset mark))) - (isearch-from-mark pane mark string forwardp))) - -(define-command (com-isearch-delete-char :name t :command-table isearch-climacs-table) () - (let* ((pane (current-window))) - (cond ((null (second (isearch-states pane))) - (display-message "Isearch: ") - (beep)) - (t - (pop (isearch-states pane)) - (loop until (endp (rest (isearch-states pane))) - until (search-success-p (first (isearch-states pane))) - do (pop (isearch-states pane))) - (let ((state (first (isearch-states pane)))) - (setf (offset (point pane)) - (if (search-forward-p state) - (+ (offset (search-mark state)) - (length (search-string state))) - (- (offset (search-mark state)) - (length (search-string state))))) - (display-message "Isearch~:[ backward~;~]: ~A" - (search-forward-p state) - (search-string state))))))) - -(define-command (com-isearch-search-forward :name t :command-table isearch-climacs-table) () - (let* ((pane (current-window)) - (point (point pane)) - (states (isearch-states pane)) - (string (if (null (second states)) - (isearch-previous-string pane) - (search-string (first states)))) - (mark (clone-mark point))) - (isearch-from-mark pane mark string t))) - -(define-command (com-isearch-search-backward :name t :command-table isearch-climacs-table) () - (let* ((pane (current-window)) - (point (point pane)) - (states (isearch-states pane)) - (string (if (null (second states)) - (isearch-previous-string pane) - (search-string (first states)))) - (mark (clone-mark point))) - (isearch-from-mark pane mark string nil))) - -(define-command (com-isearch-exit :name t :command-table isearch-climacs-table) () - (setf (isearch-mode (current-window)) nil)) - -(defun isearch-set-key (gesture command) - (add-command-to-command-table command 'isearch-climacs-table - :keystroke gesture :errorp nil)) - -(loop for code from (char-code #\Space) to (char-code #\~) - do (isearch-set-key (code-char code) 'com-isearch-append-char)) - -(isearch-set-key '(#\Newline) 'com-isearch-exit) -(isearch-set-key '(#\Backspace) 'com-isearch-delete-char) -(isearch-set-key '(#\s :control) 'com-isearch-search-forward) -(isearch-set-key '(#\r :control) 'com-isearch-search-backward) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; -;;; Query replace - -(make-command-table 'query-replace-climacs-table :errorp nil) - -(defun query-replace-find-next-match (mark string) - (flet ((object-equal (x y) - (and (characterp x) - (characterp y) - (char-equal x y)))) - (let ((offset-before (offset mark))) - (search-forward mark string :test #'object-equal) - (/= (offset mark) offset-before)))) - -(define-command (com-query-replace :name t :command-table search-table) () - (let* ((pane (current-window)) - (old-state (query-replace-state pane)) - (old-string1 (when old-state (string1 old-state))) - (old-string2 (when old-state (string2 old-state))) - (string1 (handler-case - (if old-string1 - (accept 'string - :prompt "Query Replace" - :default old-string1 - :default-type 'string) - (accept 'string :prompt "Query Replace")) - (error () (progn (beep) - (display-message "Empty string") - (return-from com-query-replace nil))))) - (string2 (handler-case - (if old-string2 - (accept 'string - :prompt (format nil "Query Replace ~A with" - string1) - :default old-string2 - :default-type 'string) - (accept 'string - :prompt (format nil "Query Replace ~A with" string1))) - (error () (progn (beep) - (display-message "Empty string") - (return-from com-query-replace nil))))) - (point (point pane)) - (occurrences 0)) - (declare (special string1 string2 occurrences)) - (when (query-replace-find-next-match point string1) - (setf (query-replace-state pane) (make-instance 'query-replace-state - :string1 string1 - :string2 string2) - (query-replace-mode pane) t) - (display-message "Query Replace ~A with ~A:" - string1 string2) - (simple-command-loop 'query-replace-climacs-table - (query-replace-mode pane) - ((setf (query-replace-mode pane) nil)))) - (display-message "Replaced ~A occurrence~:P" occurrences))) - -(set-key 'com-query-replace - 'search-table - '((#\% :shift :meta))) - -(define-command (com-query-replace-replace :name t :command-table query-replace-climacs-table) () - (declare (special string1 string2 occurrences)) - (let* ((pane (current-window)) - (point (point pane)) - (buffer (buffer pane)) - (string1-length (length string1))) - (backward-object point string1-length) - (let* ((offset1 (offset point)) - (offset2 (+ offset1 string1-length)) - (region-case (buffer-region-case buffer offset1 offset2))) - (delete-range point string1-length) - (insert-sequence point string2) - (setf offset2 (+ offset1 (length string2))) - (finish-output *error-output*) - (unless (find-if #'upper-case-p string1) - (case region-case - (:upper-case (upcase-buffer-region buffer offset1 offset2)) - (:lower-case (downcase-buffer-region buffer offset1 offset2)) - (:capitalized (capitalize-buffer-region buffer offset1 offset2))))) - (incf occurrences) - (if (query-replace-find-next-match point string1) - (display-message "Query Replace ~A with ~A:" - string1 string2) - (setf (query-replace-mode pane) nil)))) - -(define-command (com-query-replace-skip :name t :command-table query-replace-climacs-table) () - (declare (special string1 string2)) - (let* ((pane (current-window)) - (point (point pane))) - (if (query-replace-find-next-match point string1) - (display-message "Query Replace ~A with ~A:" - string1 string2) - (setf (query-replace-mode pane) nil)))) - -(define-command (com-query-replace-exit :name t :command-table query-replace-climacs-table) () - (setf (query-replace-mode (current-window)) nil)) - -(defun query-replace-set-key (gesture command) - (add-command-to-command-table command 'query-replace-climacs-table - :keystroke gesture :errorp nil)) - -(query-replace-set-key '(#\Newline) 'com-query-replace-exit) -(query-replace-set-key '(#\Space) 'com-query-replace-replace) -(query-replace-set-key '(#\Backspace) 'com-query-replace-skip) -(query-replace-set-key '(#\Rubout) 'com-query-replace-skip) -(query-replace-set-key '(#\q) 'com-query-replace-exit) -(query-replace-set-key '(#\y) 'com-query-replace-replace) -(query-replace-set-key '(#\n) 'com-query-replace-skip) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; -;;; Undo/redo - -(define-command (com-undo :name t :command-table editing-table) () - (handler-case (undo (undo-tree (buffer (current-window)))) - (no-more-undo () (beep) (display-message "No more undo"))) - (full-redisplay (current-window))) - -(set-key 'com-undo - 'editing-table - '((#\_ :shift :control))) - -(set-key 'com-undo - 'editing-table - '((#\x :control) (#\u))) - -(define-command (com-redo :name t :command-table editing-table) () - (handler-case (redo (undo-tree (buffer (current-window)))) - (no-more-undo () (beep) (display-message "No more redo"))) - (full-redisplay (current-window))) - -(set-key 'com-redo - 'editing-table - '((#\_ :shift :meta))) - -(set-key 'com-redo - 'editing-table - '((#\x :control) (#\r :control))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; -;;; Dynamic abbrevs - -(define-command (com-dabbrev-expand :name t :command-table editing-table) () - (let* ((window (current-window)) - (point (point window))) - (with-slots (original-prefix prefix-start-offset dabbrev-expansion-mark) window - (flet ((move () (cond ((beginning-of-buffer-p dabbrev-expansion-mark) - (setf (offset dabbrev-expansion-mark) - (offset point)) - (forward-word dabbrev-expansion-mark)) - ((mark< dabbrev-expansion-mark point) - (backward-object dabbrev-expansion-mark)) - (t (forward-object dabbrev-expansion-mark))))) - (unless (or (beginning-of-buffer-p point) - (not (constituentp (object-before point)))) - (unless (and (eq (previous-command window) 'com-dabbrev-expand) - (not (null prefix-start-offset))) - (setf dabbrev-expansion-mark (clone-mark point)) - (backward-word dabbrev-expansion-mark) - (setf prefix-start-offset (offset dabbrev-expansion-mark)) - (setf original-prefix (region-to-sequence prefix-start-offset point)) - (move)) - (loop until (or (end-of-buffer-p dabbrev-expansion-mark) - (and (or (beginning-of-buffer-p dabbrev-expansion-mark) - (not (constituentp (object-before dabbrev-expansion-mark)))) - (looking-at dabbrev-expansion-mark original-prefix))) - do (move)) - (if (end-of-buffer-p dabbrev-expansion-mark) - (progn (delete-region prefix-start-offset point) - (insert-sequence point original-prefix) - (setf prefix-start-offset nil)) - (progn (delete-region prefix-start-offset point) - (insert-sequence point - (let ((offset (offset dabbrev-expansion-mark))) - (prog2 (forward-word dabbrev-expansion-mark) - (region-to-sequence offset dabbrev-expansion-mark) - (setf (offset dabbrev-expansion-mark) offset)))) - (move)))))))) - -(set-key 'com-dabbrev-expand - 'editing-table - '((#\/ :meta))) - -(define-command (com-backward-paragraph :name t :command-table movement-table) - ((count 'integer :prompt "Number of paragraphs")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (backward-paragraph point syntax)) - (loop repeat (- count) do (forward-paragraph point syntax))))) - -(set-key `(com-backward-paragraph ,*numeric-argument-marker*) - 'movement-table - '((#\{ :shift :meta))) - -(define-command (com-forward-paragraph :name t :command-table movement-table) - ((count 'integer :prompt "Number of paragraphs")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (forward-paragraph point syntax)) - (loop repeat (- count) do (backward-paragraph point syntax))))) - -(set-key `(com-forward-paragraph ,*numeric-argument-marker*) - 'movement-table - '((#\} :shift :meta))) - -(define-command (com-mark-paragraph :name t :command-table marking-table) - ((count 'integer :prompt "Number of paragraphs")) - (let* ((pane (current-window)) - (point (point pane)) - (mark (mark pane)) - (syntax (syntax (buffer pane)))) - (unless (eq (previous-command pane) 'com-mark-paragraph) - (setf (offset mark) (offset point)) - (if (plusp count) - (backward-paragraph point syntax) - (forward-paragraph point syntax))) - (if (plusp count) - (loop repeat count do (forward-paragraph mark syntax)) - (loop repeat (- count) do (backward-paragraph mark syntax))))) - -(set-key `(com-mark-paragraph ,*numeric-argument-marker*) - 'marking-table - '((#\h :meta))) - -(define-command (com-backward-sentence :name t :command-table movement-table) - ((count 'integer :prompt "Number of sentences")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (backward-sentence point syntax)) - (loop repeat (- count) do (forward-sentence point syntax))))) - -(set-key `(com-backward-sentence ,*numeric-argument-marker*) - 'movement-table - '((#\a :meta))) - -(define-command (com-forward-sentence :name t :command-table movement-table) - ((count 'integer :prompt "Number of sentences")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (forward-sentence point syntax)) - (loop repeat (- count) do (backward-sentence point syntax))))) - -(set-key `(com-forward-sentence ,*numeric-argument-marker*) - 'movement-table - '((#\e :meta))) - -(define-command (com-kill-sentence :name t :command-table deletion-table) - ((count 'integer :prompt "Number of sentences")) - (let* ((pane (current-window)) - (point (point pane)) - (mark (clone-mark point)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (forward-sentence point syntax)) - (loop repeat (- count) do (backward-sentence point syntax))) - (kill-ring-standard-push *kill-ring* (region-to-sequence point mark)) - (delete-region point mark))) - -(set-key `(com-kill-sentence ,*numeric-argument-marker*) - 'deletion-table - '((#\k :meta))) - -(define-command (com-backward-kill-sentence :name t :command-table deletion-table) - ((count 'integer :prompt "Number of sentences")) - (let* ((pane (current-window)) - (point (point pane)) - (mark (clone-mark point)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (backward-sentence point syntax)) - (loop repeat (- count) do (forward-sentence point syntax))) - (kill-ring-standard-push *kill-ring* (region-to-sequence point mark)) - (delete-region point mark))) - -(set-key `(com-backward-kill-sentence ,*numeric-argument-marker*) - 'deletion-table - '((#\x :control) (#\Backspace))) - -(defun forward-page (mark &optional (count 1)) - (loop repeat count - unless (search-forward mark (coerce (list #\Newline #\Page) 'vector)) - do (end-of-buffer mark) - (loop-finish))) - -(define-command (com-forward-page :name t :command-table movement-table) - ((count 'integer :prompt "Number of pages")) - (let* ((pane (current-window)) - (point (point pane))) - (if (plusp count) - (forward-page point count) - (backward-page point count)))) - -(set-key `(com-forward-page ,*numeric-argument-marker*) - 'movement-table - '((#\x :control) (#\]))) - -(defun backward-page (mark &optional (count 1)) - (loop repeat count - when (search-backward mark (coerce (list #\Newline #\Page) 'vector)) - do (forward-object mark) - else do (beginning-of-buffer mark) - (loop-finish))) - -(define-command (com-backward-page :name t :command-table movement-table) - ((count 'integer :prompt "Number of pages")) - (let* ((pane (current-window)) - (point (point pane))) - (if (plusp count) - (backward-page point count) - (forward-page point count)))) - -(set-key `(com-backward-page ,*numeric-argument-marker*) - 'movement-table - '((#\x :control) (#\[))) - -(define-command (com-mark-page :name t :command-table marking-table) - ((count 'integer :prompt "Move how many pages") - (numargp 'boolean :prompt "Move to another page?")) - (let* ((pane (current-window)) - (point (point pane)) - (mark (mark pane))) - (cond ((and numargp (/= 0 count)) - (if (plusp count) - (forward-page point count) - (backward-page point (1+ count)))) - (t (backward-page point count))) - (setf (offset mark) (offset point)) - (forward-page mark 1))) - -(set-key `(com-mark-page ,*numeric-argument-marker* ,*numeric-argument-p*) - 'marking-table - '((#\x :control) (#\p :control))) - -(define-command (com-count-lines-page :name t :command-table info-table) () - (let* ((pane (current-window)) - (point (point pane)) - (start (clone-mark point)) - (end (clone-mark point))) - (backward-page start) - (forward-page end) - (let ((total (number-of-lines-in-region start end)) - (before (number-of-lines-in-region start point)) - (after (number-of-lines-in-region point end))) - (display-message "Page has ~A lines (~A + ~A)" total before after)))) - -(set-key 'com-count-lines-page - 'info-table - '((#\x :control) (#\l))) - -(define-command (com-count-lines-region :name t :command-table info-table) () - (let* ((pane (current-window)) - (point (point pane)) - (mark (mark pane)) - (lines (number-of-lines-in-region point mark)) - (chars (abs (- (offset point) (offset mark))))) - (display-message "Region has ~D line~:P, ~D character~:P." lines chars))) - -(set-key 'com-count-lines-region - 'info-table - '((#\= :meta))) - -(define-command (com-what-cursor-position :name t :command-table info-table) () - (let* ((pane (current-window)) - (point (point pane)) - (buffer (buffer pane)) - (offset (offset point)) - (size (size buffer)) - (char (object-after point)) - (column (column-number point))) - (display-message "Char: ~:C (#o~O ~:*~D ~:*#x~X) point=~D of ~D (~D%) column ~D" - char (char-code char) offset size - (round (* 100 (/ offset size))) column))) - -(set-key 'com-what-cursor-position - 'info-table - '((#\x :control) (#\=))) - -(define-command (com-eval-expression :name t :command-table base-table) - ((insertp 'boolean :prompt "Insert?")) - (let* ((*package* (find-package :climacs-gui)) - (string (handler-case (accept 'string :prompt "Eval") - (error () (progn (beep) - (display-message "Empty string") - (return-from com-eval-expression nil))))) - (values (multiple-value-list - (handler-case (eval (read-from-string string)) - (error (condition) (progn (beep) - (display-message "~a" condition) - (return-from com-eval-expression nil)))))) - (result (format nil "~:[; No values~;~:*~{~S~^,~}~]" values))) - (if insertp - (insert-sequence (point (current-window)) result) - (display-message result)))) - -(set-key `(com-eval-expression ,*numeric-argument-p*) - 'base-table - '((#\: :shift :meta))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; -;;; Commenting - -;;; figure out how to make commands without key bindings accept numeric arguments. -(define-command (com-comment-region :name t :command-table comment-table) () - (let* ((pane (current-window)) - (point (point pane)) - (mark (mark pane)) - (syntax (syntax (buffer pane)))) - (comment-region syntax point mark))) - -(define-command (com-backward-expression :name t :command-table movement-table) - ((count 'integer :prompt "Number of expressions")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (backward-expression point syntax)) - (loop repeat (- count) do (forward-expression point syntax))))) - -(set-key `(com-backward-expression ,*numeric-argument-marker*) - 'movement-table - '((#\b :control :meta))) - -(define-command (com-forward-expression :name t :command-table movement-table) - ((count 'integer :prompt "Number of expresssions")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (forward-expression point syntax)) - (loop repeat (- count) do (backward-expression point syntax))))) - -(set-key `(com-forward-expression ,*numeric-argument-marker*) - 'movement-table - '((#\f :control :meta))) - -(define-command (com-mark-expression :name t :command-table marking-table) - ((count 'integer :prompt "Number of expressions")) - (let* ((pane (current-window)) - (point (point pane)) - (mark (mark pane)) - (syntax (syntax (buffer pane)))) - (unless (eq (previous-command pane) 'com-mark-expression) - (setf (offset mark) (offset point))) - (if (plusp count) - (loop repeat count do (forward-expression mark syntax)) - (loop repeat (- count) do (backward-expression mark syntax))))) - -(set-key `(com-mark-expression ,*numeric-argument-marker*) - 'marking-table - '((#\@ :shift :control :meta))) - -(define-command (com-kill-expression :name t :command-table deletion-table) - ((count 'integer :prompt "Number of expressions")) - (let* ((pane (current-window)) - (point (point pane)) - (mark (clone-mark point)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (forward-expression mark syntax)) - (loop repeat (- count) do (backward-expression mark syntax))) - (kill-ring-standard-push *kill-ring* (region-to-sequence mark point)) - (delete-region mark point))) - -(set-key `(com-kill-expression ,*numeric-argument-marker*) - 'deletion-table - '((#\k :control :meta))) - -(define-command (com-backward-kill-expression :name t :command-table deletion-table) - ((count 'integer :prompt "Number of expressions")) - (let* ((pane (current-window)) - (point (point pane)) - (mark (clone-mark point)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (backward-expression mark syntax)) - (loop repeat (- count) do (forward-expression mark syntax))) - (kill-ring-standard-push *kill-ring* (region-to-sequence mark point)) - (delete-region mark point))) - -(set-key `(com-backward-kill-expression ,*numeric-argument-marker*) - 'deletion-table - '((#\Backspace :control :meta))) - -;; (defparameter *insert-pair-alist* -;; '((#\( #\)) (#\[ #\]) (#\{ #\}) (#\< #\>) (#\" #\") (#\' #\') (#\` #\'))) - -(defun insert-pair (mark syntax &optional (count 0) (open #\() (close #\))) - (cond ((> count 0) - (loop while (and (not (end-of-buffer-p mark)) - (whitespacep (object-after mark))) - do (forward-object mark))) - ((< count 0) - (setf count (- count)) - (loop repeat count do (backward-expression mark syntax)))) - (unless (or (beginning-of-buffer-p mark) - (whitespacep (object-before mark))) - (insert-object mark #\Space)) - (insert-object mark open) - (let ((here (clone-mark mark))) - (loop repeat count - do (forward-expression here syntax)) - (insert-object here close) - (unless (or (end-of-buffer-p here) - (whitespacep (object-after here))) - (insert-object here #\Space)))) - -(defun insert-parentheses (mark syntax count) - (insert-pair mark syntax count #\( #\))) - -(define-command (com-insert-parentheses :name t :command-table editing-table) - ((count 'integer :prompt "Number of expressions") - (wrap-p 'boolean :prompt "Wrap expressions?")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (unless wrap-p (setf count 0)) - (insert-parentheses point syntax count))) - -(set-key `(com-insert-parentheses ,*numeric-argument-marker* ,*numeric-argument-p*) - 'editing-table - '((#\( :meta))) - -(define-command (com-forward-list :name t :command-table movement-table) - ((count 'integer :prompt "Number of lists")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (forward-list point syntax)) - (loop repeat (- count) do (backward-list point syntax))))) - -(set-key `(com-forward-list ,*numeric-argument-marker*) - 'movement-table - '((#\n :control :meta))) - -(define-command (com-backward-list :name t :command-table movement-table) - ((count 'integer :prompt "Number of lists")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (backward-list point syntax)) - (loop repeat (- count) do (forward-list point syntax))))) - -(set-key `(com-backward-list ,*numeric-argument-marker*) - 'movement-table - '((#\p :control :meta))) - -(define-command (com-down-list :name t :command-table movement-table) - ((count 'integer :prompt "Number of lists")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (down-list point syntax)) - (loop repeat (- count) do (backward-down-list point syntax))))) - -(set-key `(com-down-list ,*numeric-argument-marker*) - 'movement-table - '((#\d :control :meta))) - -(define-command (com-backward-down-list :name t :command-table movement-table) - ((count 'integer :prompt "Number of lists")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (backward-down-list point syntax)) - (loop repeat (- count) do (down-list point syntax))))) - -(define-command (com-backward-up-list :name t :command-table movement-table) - ((count 'integer :prompt "Number of lists")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (backward-up-list point syntax)) - (loop repeat (- count) do (up-list point syntax))))) - -(set-key `(com-backward-up-list ,*numeric-argument-marker*) - 'movement-table - '((#\u :control :meta))) - -(define-command (com-up-list :name t :command-table movement-table) ((count 'integer :prompt "Number of lists")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (up-list point syntax)) - (loop repeat (- count) do (backward-up-list point syntax))))) - -(define-command (com-eval-defun :name t :command-table lisp-table) () - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (eval-defun point syntax))) - -(set-key 'com-eval-defun - 'lisp-table - '((#\x :control :meta))) - -(define-command (com-beginning-of-definition :name t :command-table movement-table) - ((count 'integer :prompt "Number of definitions")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (beginning-of-definition point syntax)) - (loop repeat (- count) do (end-of-definition point syntax))))) - -(set-key `(com-beginning-of-definition ,*numeric-argument-marker*) - 'movement-table - '((#\a :control :meta))) - -(define-command (com-end-of-definition :name t :command-table movement-table) - ((count 'integer :prompt "Number of definitions")) - (let* ((pane (current-window)) - (point (point pane)) - (syntax (syntax (buffer pane)))) - (if (plusp count) - (loop repeat count do (end-of-definition point syntax)) - (loop repeat (- count) do (beginning-of-definition point syntax))))) - -(set-key `(com-end-of-definition ,*numeric-argument-marker*) - 'movement-table - '((#\e :control :meta))) - -(define-command (com-mark-definition :name t :command-table marking-table) () - (let* ((pane (current-window)) - (point (point pane)) - (mark (mark pane)) - (syntax (syntax (buffer pane)))) - (unless (eq (previous-command pane) 'com-mark-definition) - (beginning-of-definition point syntax) - (setf (offset mark) (offset point))) - (end-of-definition mark syntax))) - -(set-key 'com-mark-definition - 'marking-table - '((#\h :control :meta))) - -(define-command (com-package :name t :command-table lisp-table) () - (let* ((pane (current-window)) - (syntax (syntax (buffer pane))) - (package (climacs-lisp-syntax::package-of syntax))) - (display-message (format nil "~s" package)))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; -;;; For testing purposes - -(define-command (com-reset-profile :name t :command-table development-table) () - #+sbcl (sb-profile:reset) - #-sbcl nil) - -(define-command (com-report-profile :name t :command-table development-table) () - #+sbcl (sb-profile:report) - #-sbcl nil) - -(define-command (com-recompile :name t :command-table development-table) () - (asdf:operate 'asdf:load-op :climacs)) - - -(define-gesture-name :select-other :pointer-button-press (:left :meta) :unique nil) - -(define-presentation-translator lisp-string-to-string - (climacs-lisp-syntax::lisp-string string development-table - :gesture :select-other - :tester-definitive t - :menu nil - :priority 10) - (object) - object) - -(define-command (com-accept-string :name t :command-table development-table) () - (display-message (format nil "~s" (accept 'string)))) - -(define-command (com-accept-symbol :name t :command-table development-table) () - (display-message (format nil "~s" (accept 'symbol)))) - -(define-command (com-accept-lisp-string :name t :command-table development-table) () - (display-message (format nil "~s" (accept 'lisp-string)))) - -(define-command (com-visible-mark :name t :command-table marking-table) () - (setf (mark-visible-p (current-window)) (not (mark-visible-p (current-window))))) - -(loop for code from (char-code #\Space) to (char-code #\~) - do (set-key `(com-self-insert ,*numeric-argument-marker*) - 'self-insert-table - (list (list (code-char code))))) - -(set-key `(com-self-insert ,*numeric-argument-marker*) - 'self-insert-table - '((#\Newline))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; -;;; Some Unicode stuff - -(define-command (com-insert-charcode :name t :command-table self-insert-table) - ((code 'integer :prompt "Code point")) - (insert-object (point (current-window)) (code-char code))) - -(set-key '(com-insert-charcode 193) 'self-insert-table '((:dead--acute)(#\A))) -(set-key '(com-insert-charcode 201) 'self-insert-table '((:dead--acute)(#\E))) -(set-key '(com-insert-charcode 205) 'self-insert-table '((:dead--acute)(#\I))) -(set-key '(com-insert-charcode 211) 'self-insert-table '((:dead--acute)(#\O))) -(set-key '(com-insert-charcode 218) 'self-insert-table '((:dead--acute)(#\U))) -(set-key '(com-insert-charcode 221) 'self-insert-table '((:dead--acute)(#\Y))) -(set-key '(com-insert-charcode 225) 'self-insert-table '((:dead--acute)(#\a))) -(set-key '(com-insert-charcode 233) 'self-insert-table '((:dead--acute)(#\e))) -(set-key '(com-insert-charcode 237) 'self-insert-table '((:dead--acute)(#\i))) -(set-key '(com-insert-charcode 243) 'self-insert-table '((:dead--acute)(#\o))) -(set-key '(com-insert-charcode 250) 'self-insert-table '((:dead--acute)(#\u))) -(set-key '(com-insert-charcode 253) 'self-insert-table '((:dead--acute)(#\y))) -(set-key '(com-insert-charcode 199) 'self-insert-table '((:dead--acute)(#\C))) -(set-key '(com-insert-charcode 231) 'self-insert-table '((:dead--acute)(#\c))) -(set-key '(com-insert-charcode 215) 'self-insert-table '((:dead--acute)(#\x))) -(set-key '(com-insert-charcode 247) 'self-insert-table '((:dead--acute)(#\-))) -(set-key '(com-insert-charcode 222) 'self-insert-table '((:dead--acute)(#\T))) -(set-key '(com-insert-charcode 254) 'self-insert-table '((:dead--acute)(#\t))) -(set-key '(com-insert-charcode 223) 'self-insert-table '((:dead--acute)(#\s))) -(set-key '(com-insert-charcode 39) 'self-insert-table '((:dead--acute)(#\Space))) - -(set-key '(com-insert-charcode 197) 'self-insert-table '((:dead--acute)(:dead--acute)(#\A))) -(set-key '(com-insert-charcode 229) 'self-insert-table '((:dead--acute)(:dead--acute)(#\a))) - -(set-key '(com-insert-charcode 192) 'self-insert-table '((:dead--grave)(#\A))) -(set-key '(com-insert-charcode 200) 'self-insert-table '((:dead--grave)(#\E))) -(set-key '(com-insert-charcode 204) 'self-insert-table '((:dead--grave)(#\I))) -(set-key '(com-insert-charcode 210) 'self-insert-table '((:dead--grave)(#\O))) -(set-key '(com-insert-charcode 217) 'self-insert-table '((:dead--grave)(#\U))) -(set-key '(com-insert-charcode 224) 'self-insert-table '((:dead--grave)(#\a))) -(set-key '(com-insert-charcode 232) 'self-insert-table '((:dead--grave)(#\e))) -(set-key '(com-insert-charcode 236) 'self-insert-table '((:dead--grave)(#\i))) -(set-key '(com-insert-charcode 242) 'self-insert-table '((:dead--grave)(#\o))) -(set-key '(com-insert-charcode 249) 'self-insert-table '((:dead--grave)(#\u))) -(set-key '(com-insert-charcode 96) 'self-insert-table '((:dead--grave)(#\Space))) - -(set-key '(com-insert-charcode 196) 'self-insert-table '((:dead--diaeresis :shift)(#\A))) -(set-key '(com-insert-charcode 203) 'self-insert-table '((:dead--diaeresis :shift)(#\E))) -(set-key '(com-insert-charcode 207) 'self-insert-table '((:dead--diaeresis :shift)(#\I))) -(set-key '(com-insert-charcode 214) 'self-insert-table '((:dead--diaeresis :shift)(#\O))) -(set-key '(com-insert-charcode 220) 'self-insert-table '((:dead--diaeresis :shift)(#\U))) -(set-key '(com-insert-charcode 228) 'self-insert-table '((:dead--diaeresis :shift)(#\a))) -(set-key '(com-insert-charcode 235) 'self-insert-table '((:dead--diaeresis :shift)(#\e))) -(set-key '(com-insert-charcode 239) 'self-insert-table '((:dead--diaeresis :shift)(#\i))) -(set-key '(com-insert-charcode 246) 'self-insert-table '((:dead--diaeresis :shift)(#\o))) -(set-key '(com-insert-charcode 252) 'self-insert-table '((:dead--diaeresis :shift)(#\u))) -(set-key '(com-insert-charcode 255) 'self-insert-table '((:dead--diaeresis :shift)(#\y))) -(set-key '(com-insert-charcode 34) 'self-insert-table '((:dead--diaeresis :shift)(#\Space))) - -(set-key '(com-insert-charcode 195) 'self-insert-table '((:dead--tilde :shift)(#\A))) -(set-key '(com-insert-charcode 209) 'self-insert-table '((:dead--tilde :shift)(#\N))) -(set-key '(com-insert-charcode 227) 'self-insert-table '((:dead--tilde :shift)(#\a))) -(set-key '(com-insert-charcode 241) 'self-insert-table '((:dead--tilde :shift)(#\n))) -(set-key '(com-insert-charcode 198) 'self-insert-table '((:dead--tilde :shift)(#\E))) -(set-key '(com-insert-charcode 230) 'self-insert-table '((:dead--tilde :shift)(#\e))) -(set-key '(com-insert-charcode 208) 'self-insert-table '((:dead--tilde :shift)(#\D))) -(set-key '(com-insert-charcode 240) 'self-insert-table '((:dead--tilde :shift)(#\d))) -(set-key '(com-insert-charcode 216) 'self-insert-table '((:dead--tilde :shift)(#\O))) -(set-key '(com-insert-charcode 248) 'self-insert-table '((:dead--tilde :shift)(#\o))) -(set-key '(com-insert-charcode 126) 'self-insert-table '((:dead--tilde :shift)(#\Space))) - -(set-key '(com-insert-charcode 194) 'self-insert-table '((:dead--circumflex :shift)(#\A))) -(set-key '(com-insert-charcode 202) 'self-insert-table '((:dead--circumflex :shift)(#\E))) -(set-key '(com-insert-charcode 206) 'self-insert-table '((:dead--circumflex :shift)(#\I))) -(set-key '(com-insert-charcode 212) 'self-insert-table '((:dead--circumflex :shift)(#\O))) -(set-key '(com-insert-charcode 219) 'self-insert-table '((:dead--circumflex :shift)(#\U))) -(set-key '(com-insert-charcode 226) 'self-insert-table '((:dead--circumflex :shift)(#\a))) -(set-key '(com-insert-charcode 234) 'self-insert-table '((:dead--circumflex :shift)(#\e))) -(set-key '(com-insert-charcode 238) 'self-insert-table '((:dead--circumflex :shift)(#\i))) -(set-key '(com-insert-charcode 244) 'self-insert-table '((:dead--circumflex :shift)(#\o))) -(set-key '(com-insert-charcode 251) 'self-insert-table '((:dead--circumflex :shift)(#\u))) -(set-key '(com-insert-charcode 94) 'self-insert-table '((:dead--circumflex :shift)(#\Space))) - -(define-command (com-regex-search-forward :name t :command-table search-table) () - (let ((string (accept 'string :prompt "RE search" - :delimiter-gestures nil - :activation-gestures - '(:newline :return)))) - (re-search-forward (point (current-window)) string))) - -(define-command (com-regex-search-backward :name t :command-table search-table) () - (let ((string (accept 'string :prompt "RE search backward" - :delimiter-gestures nil - :activation-gestures - '(:newline :return)))) - (re-search-backward (point (current-window)) string))) Index: climacs/climacs.asd diff -u climacs/climacs.asd:1.38 climacs/climacs.asd:1.39 --- climacs/climacs.asd:1.38 Sun Sep 25 22:06:25 2005 +++ climacs/climacs.asd Sat Nov 12 10:34:34 2005 @@ -72,6 +72,13 @@ (:file "esa" :depends-on ("packages")) (:file "gui" :depends-on ("packages" "syntax" "base" "buffer" "undo" "pane" "esa" "kill-ring" "io" "text-syntax" "abbrev")) +;; (:file "buffer-commands" :depends-on ("gui")) + (:file "developer-commands" :depends-on ("gui" "lisp-syntax")) + (:file "file-commands" :depends-on ("gui")) + (:file "misc-commands" :depends-on ("gui")) + (:file "search-commands" :depends-on ("gui")) + (:file "window-commands" :depends-on ("gui")) + (:file "unicode-commands" :depends-on ("gui")) (:file "slidemacs" :depends-on ("packages" "buffer" "syntax" "base" "pane")) (:file "slidemacs-gui" :depends-on ("packages" "slidemacs" "pane" "buffer" "syntax" "gui")))) Index: climacs/cl-syntax.lisp diff -u climacs/cl-syntax.lisp:1.15 climacs/cl-syntax.lisp:1.16 --- climacs/cl-syntax.lisp:1.15 Tue Aug 16 01:31:22 2005 +++ climacs/cl-syntax.lisp Sat Nov 12 10:34:34 2005 @@ -116,7 +116,7 @@ (valid-parse :initform 1) (parser)) (:name "Common Lisp") - (:pathname-types "lisp" "lsp" "cl")) + (:pathname-types "lsp" "cl")) (defun neutralcharp (var) (and (characterp var)