1050 lines
31 KiB
Scheme
1050 lines
31 KiB
Scheme
;; ,load /home/demattia/studium/studienarbeit/scsh-nuit/scheme/nuit-engine.scm
|
|
|
|
|
|
;;This is the "heart" of NUIT.
|
|
;;In a central loop the program waits for input (with wgetch).
|
|
;;In the upper buffer simply the functionalities of scsh-ncurses:
|
|
;;input-buffer are used.
|
|
;;The lower window is meant to be used more flexible. Depending on
|
|
;;the active command the key-inputs are routed to the correct receiver,
|
|
;;where one can specify how to react.
|
|
|
|
;;*************************************************************************
|
|
;;State
|
|
|
|
(define-record-type app-window :app-window
|
|
(make-app-window x y width height curses-win)
|
|
app-window?
|
|
(x app-window-x)
|
|
(y app-window-y)
|
|
(width app-window-width)
|
|
(height app-window-height)
|
|
(curses-win app-window-curses-win set-app-window-curses-win!))
|
|
|
|
(define bar-1 #f)
|
|
(define bar-2 #f)
|
|
(define command-frame-window #f)
|
|
(define command-window #f)
|
|
(define result-window #f)
|
|
|
|
(define shortcuts '("F1:Exit"
|
|
"F2:Repaint (after change of buffer size)"
|
|
"Ctrl+x o:Switch Buffer"
|
|
"Ctrl+x s:Insert/Select"
|
|
"Ctrl+x u:-/Unselect"
|
|
"PageUp - previous entry in result history"
|
|
"PageDown - next entry in result history"
|
|
"Ctrl+x r:Redo (Active Command)"
|
|
"CursorUp - previous entry in command history"
|
|
"CursorDown - next entry in command history"
|
|
"Ctrl+a:First Pos of Line"
|
|
"Ctrl+e:End of Line"
|
|
"Ctrl+k:Delete Line"))
|
|
|
|
;;state of the upper window (Command-Window)
|
|
(define command-buffer
|
|
(make-buffer '("Welcome to the scsh-ncurses-ui!" "")
|
|
2 2 2 1 1
|
|
0 0
|
|
#t 1))
|
|
|
|
;;state of the lower window (Result-Window)
|
|
;;----------------------------
|
|
;;Text
|
|
(define text-result (list "Type 'shortcuts' for help"))
|
|
|
|
;;line of the result-window
|
|
(define pos-result 0)
|
|
|
|
;;column
|
|
(define pos-result-col 0)
|
|
|
|
;;y-coordinate of the cursor in the result-buffer
|
|
(define result-buffer-pos-y 0)
|
|
|
|
;;x-coordinate of the cursor in the result-buffer
|
|
(define result-buffer-pos-x 0)
|
|
|
|
;;lines of the lower window
|
|
(define result-lines 0)
|
|
|
|
;;columns in the lower window
|
|
(define result-cols 0)
|
|
|
|
;;lines to be highlighted
|
|
(define highlighted-lines '())
|
|
|
|
;;lines to be marked
|
|
(define marked-lines '())
|
|
|
|
|
|
|
|
|
|
;;miscelaneous state
|
|
;;-------------------
|
|
|
|
(define *focus-buffer* 'command-buffer)
|
|
|
|
(define (focus-on-command-buffer?)
|
|
(eq? *focus-buffer* 'command-buffer))
|
|
|
|
(define (focus-command-buffer!)
|
|
(set! *focus-buffer* 'command-buffer))
|
|
|
|
(define (focus-on-result-buffer?)
|
|
(eq? *focus-buffer* 'result-buffer))
|
|
|
|
(define (focus-result-buffer!)
|
|
(set! *focus-buffer* 'result-buffer))
|
|
|
|
;;History
|
|
(define history '())
|
|
|
|
;;Position in the "elaborated" History
|
|
(define history-pos 0)
|
|
|
|
;;data-type for history.entries
|
|
(define-record-type history-entry history-entry
|
|
(make-history-entry command
|
|
parameters
|
|
result-object)
|
|
history-entry?
|
|
(command history-entry-command)
|
|
(parameters history-entry-parameters)
|
|
(result-object history-entry-result-object))
|
|
|
|
;;active command
|
|
(define active-command "")
|
|
|
|
;;sctive parameters
|
|
(define active-parameters "")
|
|
|
|
;;active result-object
|
|
(define current-result-object)
|
|
|
|
;;active keyboard-interrupt:
|
|
;;after each input this is set to #f.
|
|
;;If a keyboard-interrupt occurs this can be checked by looking-up this box
|
|
(define active-keyboard-interrupt #f)
|
|
|
|
;;This indicates if the last input was Ctrl-x
|
|
(define c-x-pressed #f)
|
|
|
|
|
|
;;Message-Types
|
|
;;---------------------
|
|
;;A new command was entered
|
|
;;->create a new "object"
|
|
(define-record-type next-command-message next-command-message
|
|
(make-next-command-message command-string
|
|
parameters
|
|
width)
|
|
next-command-message?
|
|
(command-string next-command-string)
|
|
(parameters next-command-message-parameters)
|
|
(width next-command-message-width))
|
|
|
|
;;key pressed
|
|
;;The object and the key are send to the user-code, who returns the
|
|
;;changed object.
|
|
(define-record-type key-pressed-message key-pressed-message
|
|
(make-key-pressed-message command-string
|
|
result-model
|
|
key)
|
|
key-pressed-message?
|
|
(command-string key-pressed-command-string)
|
|
(result-model key-pressed-message-result-model)
|
|
(key key-pressed-message-key))
|
|
|
|
;;print
|
|
(define-record-type print-message print-message
|
|
(make-print-message command-string
|
|
object
|
|
width)
|
|
print-message?
|
|
(command-string print-message-command-string)
|
|
(object print-message-object)
|
|
(width print-message-width))
|
|
|
|
;;->this sort of data-type is returned by a print-message
|
|
(define-record-type print-object print-object
|
|
(make-print-object pos-y
|
|
pos-x
|
|
text
|
|
highlighted-lines
|
|
marked-lines)
|
|
(pos-y print-object-pos-y)
|
|
(pos-x print-object-pos-x)
|
|
(text print-object-text)
|
|
(highlighted-lines print-object-highlighted-lines)
|
|
(marked-lines print-object-marked-lines))
|
|
|
|
;;restore (when side-effects occur)
|
|
(define-record-type restore-message restore-message
|
|
(make-restore-message command-string
|
|
object)
|
|
restore-message?
|
|
(command-string restore-message-command-string)
|
|
(object restore-message-object))
|
|
|
|
;;request the selection
|
|
(define-record-type selection-message selection-message
|
|
(make-selection-message command-string
|
|
object)
|
|
selection-message?
|
|
(command-string selection-message-command-string)
|
|
(object selection-message-object))
|
|
|
|
;;The "user" (who extends the functionality of NUIT) has to inform NUIT
|
|
;;about which function is meant to be the receiver, when a certain
|
|
;;command is active
|
|
(define-record-type receiver receiver
|
|
(make-receiver command rec)
|
|
receiver?
|
|
(command receiver-command)
|
|
(rec receiver-rec))
|
|
|
|
;;This list contains all the receivers that have been registered.
|
|
(define receivers '())
|
|
|
|
;;*************************************************************************
|
|
;;Actions
|
|
|
|
;;start the whole thing
|
|
(define (nuit)
|
|
(with-inspecting-handler
|
|
8888
|
|
(lambda (condition)
|
|
(with-current-output-port*
|
|
(error-output-port)
|
|
(lambda ()
|
|
(display "starting remote handler for condition")
|
|
(display condition)
|
|
(newline)
|
|
(display "Please connect to port 8888")
|
|
(newline)
|
|
#t)))
|
|
run))
|
|
|
|
;;handle input
|
|
(define (run)
|
|
|
|
'(set-interrupt-handler interrupt/keyboard
|
|
(lambda a
|
|
(set! active-keyboard-interrupt a)))
|
|
|
|
;;Loop
|
|
(paint)
|
|
(let loop ((ch (wait-for-input)))
|
|
(cond
|
|
;;The result of pressing these keys is independent of which
|
|
;;Buffer is active
|
|
;;Finish
|
|
((= ch key-f1)
|
|
(begin
|
|
(let ((restore-message (make-restore-message
|
|
active-command
|
|
current-result-object)))
|
|
(switch restore-message)
|
|
(restore-state))
|
|
(endwin)
|
|
(display "")))
|
|
|
|
((= ch key-f2)
|
|
(endwin)
|
|
(run))
|
|
|
|
;;Ctrl-x -> wait for next input
|
|
((= ch 24)
|
|
(begin
|
|
(set! c-x-pressed (not c-x-pressed))
|
|
(if (focus-on-result-buffer?)
|
|
(let ((key-message
|
|
(make-key-pressed-message active-command
|
|
current-result-object
|
|
ch)))
|
|
(set! current-result-object (switch key-message))))
|
|
(paint)
|
|
(loop (wait-for-input))))
|
|
|
|
;; forward in result history
|
|
((= ch key-npage)
|
|
(history-forward)
|
|
(paint-result-window)
|
|
(loop (wait-for-input)))
|
|
|
|
;; back in result history
|
|
((= ch key-ppage)
|
|
(history-back)
|
|
(paint-result-window)
|
|
(loop (wait-for-input)))
|
|
|
|
;;if lower window is active a message is sent.
|
|
(else
|
|
(if c-x-pressed
|
|
(cond
|
|
|
|
;;Ctrl-x o ->switch buffer
|
|
((= ch 111)
|
|
(if (focus-on-command-buffer?)
|
|
(let ((key-message
|
|
(make-key-pressed-message active-command
|
|
current-result-object
|
|
97)))
|
|
(focus-result-buffer!)
|
|
(set! current-result-object (switch key-message))
|
|
(paint-result-window))
|
|
(begin
|
|
(focus-command-buffer!)
|
|
(paint-command-window-contents)
|
|
(set! command-buffer (move-cursor command-buffer))))
|
|
(set! c-x-pressed #f)
|
|
(loop (wait-for-input)))
|
|
|
|
;;C-x r -> redo
|
|
((= ch 114)
|
|
(if (or (> (length (buffer-text command-buffer)) 2)
|
|
(not (equal? active-command "")))
|
|
(let ((command-string (string-append active-command
|
|
active-parameters))
|
|
(text (sublist (buffer-text command-buffer) 0
|
|
(- (length (buffer-text command-buffer)) 1))))
|
|
(begin
|
|
(switch restore-message)
|
|
(set-buffer-text! (append text (list command-string)))
|
|
(execute-command)
|
|
(set-buffer-history-pos! command-buffer
|
|
(- (length (buffer-text command-buffer)) 1))
|
|
(set! c-x-pressed #f)
|
|
(endwin)
|
|
(run)))
|
|
(begin
|
|
(set! c-x-pressed #f)
|
|
(loop (wait-for-input)))))
|
|
|
|
(else
|
|
(begin
|
|
(if (focus-on-result-buffer?)
|
|
(let ((key-message
|
|
(make-key-pressed-message active-command
|
|
current-result-object
|
|
ch)))
|
|
(set! current-result-object (switch key-message)))
|
|
|
|
(if (= ch 115)
|
|
(let* ((message
|
|
(make-selection-message
|
|
active-command current-result-object))
|
|
(marked-items (switch message)))
|
|
(add-string-to-command-buffer marked-items))))
|
|
(set! c-x-pressed #f)
|
|
(loop (wait-for-input)))))
|
|
|
|
(if (focus-on-result-buffer?)
|
|
(let ((key-message
|
|
(make-key-pressed-message active-command
|
|
current-result-object
|
|
ch)))
|
|
(set! current-result-object (switch key-message))
|
|
(paint-result-window)
|
|
(loop (wait-for-input)))
|
|
|
|
(cond
|
|
|
|
;;Enter
|
|
((= ch 10)
|
|
(let ((restore-message (make-restore-message
|
|
active-command
|
|
current-result-object)))
|
|
(switch restore-message)
|
|
(execute-command)
|
|
(set-buffer-history-pos!
|
|
command-buffer
|
|
(- (length (buffer-text command-buffer)) 1))
|
|
(paint-result-window)
|
|
(paint-bar-2)
|
|
(paint-command-window-contents)
|
|
(set! command-buffer (move-cursor command-buffer))
|
|
(loop (wait-for-input))))
|
|
|
|
(else
|
|
(set! command-buffer (input command-buffer ch))
|
|
(werase (app-window-curses-win command-window))
|
|
(print-command-buffer (app-window-curses-win command-window)
|
|
command-buffer)
|
|
(set! command-buffer (move-cursor command-buffer))
|
|
(loop (wait-for-input))))))))))
|
|
|
|
(define (window-init-curses-win! window)
|
|
(set-app-window-curses-win!
|
|
window
|
|
(newwin (app-window-height window) (app-window-width window)
|
|
(app-window-y window) (app-window-x window))))
|
|
|
|
(define (init-windows!)
|
|
(init-screen)
|
|
(set! bar-1
|
|
(make-app-window 1 1
|
|
(- (COLS) 2) 2
|
|
#f))
|
|
(set! bar-2
|
|
(make-app-window 1 (+ (round (/ (LINES) 3)) 2)
|
|
(- (COLS) 2) 3
|
|
#f))
|
|
(set! command-frame-window
|
|
(make-app-window 1 2
|
|
(- (COLS) 2) (- (app-window-y bar-2) 2)
|
|
#f))
|
|
(set! command-window
|
|
(make-app-window (+ (app-window-x command-frame-window) 1)
|
|
(+ (app-window-y command-frame-window) 1)
|
|
(- (app-window-width command-frame-window) 2)
|
|
(- (app-window-height command-frame-window) 2)
|
|
#f))
|
|
(set! result-window
|
|
(make-app-window 1 (+ (app-window-y bar-2) 3)
|
|
(- (COLS) 2)
|
|
(- (- (LINES) 6) (app-window-height command-frame-window))
|
|
#f))
|
|
(window-init-curses-win! bar-1)
|
|
(window-init-curses-win! bar-2)
|
|
(window-init-curses-win! command-frame-window)
|
|
(window-init-curses-win! command-window)
|
|
(window-init-curses-win! result-window)
|
|
(wclear (app-window-curses-win bar-1))
|
|
(wclear (app-window-curses-win bar-2))
|
|
(wclear (app-window-curses-win command-window))
|
|
(wclear (app-window-curses-win command-frame-window))
|
|
(wclear (app-window-curses-win result-window))
|
|
(clear))
|
|
|
|
(define (paint-bar-1)
|
|
(mvwaddstr (app-window-curses-win bar-1) 0 1 "SCSH-NUIT")
|
|
(wrefresh (app-window-curses-win bar-1)))
|
|
|
|
(define (paint-bar-2)
|
|
(box (app-window-curses-win bar-2) (ascii->char 0) (ascii->char 0))
|
|
(print-active-command-win (app-window-curses-win bar-2)
|
|
(app-window-width bar-2)))
|
|
|
|
(define (paint-command-frame-window)
|
|
(box (app-window-curses-win command-frame-window)
|
|
(ascii->char 0) (ascii->char 0))
|
|
(wrefresh (app-window-curses-win command-frame-window)))
|
|
|
|
(define (paint-command-window-contents)
|
|
(set-buffer-num-lines! command-buffer
|
|
(- (app-window-height command-window) 2))
|
|
(set-buffer-num-cols! command-buffer
|
|
(- (app-window-width command-window) 3))
|
|
(werase (app-window-curses-win command-window))
|
|
(set! command-buffer
|
|
(print-command-buffer (app-window-curses-win command-window)
|
|
command-buffer))
|
|
(wrefresh (app-window-curses-win command-window)))
|
|
|
|
(define (paint-result-window)
|
|
(wclear (app-window-curses-win result-window))
|
|
(box (app-window-curses-win result-window)
|
|
(ascii->char 0) (ascii->char 0))
|
|
(set! result-lines (- (app-window-height result-window) 2))
|
|
(set! result-cols (- (app-window-width result-window) 3))
|
|
(print-result-buffer result-window)
|
|
(wrefresh (app-window-curses-win result-window)))
|
|
|
|
(define (paint)
|
|
(init-windows!)
|
|
(paint-bar-1)
|
|
(paint-bar-2)
|
|
(paint-command-frame-window)
|
|
(paint-command-window-contents)
|
|
(paint-result-window)
|
|
(move-cursor command-buffer))
|
|
|
|
(define (wait-for-input)
|
|
(noecho)
|
|
(keypad (app-window-curses-win bar-1) #t)
|
|
(set! active-keyboard-interrupt #f)
|
|
(let ((ch (wgetch (app-window-curses-win bar-1))))
|
|
(echo)
|
|
ch))
|
|
|
|
;;If the user presses enter the last line is interpreted as a command
|
|
;;which has to be executed.
|
|
(define (execute-command)
|
|
(let* ((com (list-ref (buffer-text command-buffer)
|
|
(- (length (buffer-text command-buffer)) 1)))
|
|
(com-par (extract-com-and-par com))
|
|
(command (car com-par))
|
|
(parameters (cdr com-par))
|
|
;;todo: parameters
|
|
(message (make-next-command-message
|
|
command parameters result-cols))
|
|
(model (switch message)))
|
|
(if (not (= history-pos 0))
|
|
(let ((hist-entry (make-history-entry active-command
|
|
active-parameters
|
|
current-result-object))
|
|
(active (make-history-entry command
|
|
(get-param-as-str parameters)
|
|
model)))
|
|
(if (< history-pos (length history))
|
|
(set! history (append history (list hist-entry)))
|
|
(set! history (append
|
|
(sublist history 0
|
|
(- (length history) 1))
|
|
(list hist-entry) (list active))))
|
|
(set! history-pos (length history)))
|
|
(let ((hist-entry (make-history-entry
|
|
command
|
|
(get-param-as-str parameters) model)))
|
|
(set! history (list hist-entry))
|
|
(set! history-pos 1)))
|
|
|
|
(set-buffer-text! command-buffer
|
|
(append (buffer-text command-buffer)
|
|
(list "")))
|
|
(set! active-command command)
|
|
(set! active-parameters (get-param-as-str parameters))
|
|
(set! current-result-object model)
|
|
(scroll-command-buffer)))
|
|
|
|
;;Extracts the name of the function and its parameters
|
|
(define extract-com-and-par
|
|
(lambda (com)
|
|
(if (<= (string-length com) 0)
|
|
(cons "" '())
|
|
(if (equal? #\( (string-ref com 0))
|
|
(cons com '())
|
|
(let* ((fst-word (get-next-word com))
|
|
(command (car fst-word))
|
|
(rest (cdr fst-word)))
|
|
(let loop ((param-str rest)
|
|
(param-list '()))
|
|
(let* ((word (get-next-word param-str))
|
|
(param (car word))
|
|
(more (cdr word)))
|
|
(if (equal? "" param)
|
|
(cons command param-list)
|
|
(loop more (append param-list (list param)))))))))))
|
|
|
|
;;gets the next word from a string
|
|
(define (get-next-word str)
|
|
(let loop ((old str)
|
|
(new ""))
|
|
(if (= 0 (string-length old))
|
|
(cons new old)
|
|
(if (char=? #\space (string-ref old 0))
|
|
(if (= 1 (string-length old))
|
|
(cons new "")
|
|
(cons new (substring old 1 (string-length old))))
|
|
(if (char=? #\( (string-ref old 0))
|
|
(let* ((nw (get-next-word-braces
|
|
(substring old 1
|
|
(string-length old))))
|
|
(nw-new (car nw))
|
|
(nw-old (cdr nw)))
|
|
(loop nw-old (string-append new "(" nw-new)))
|
|
(loop (substring old 1 (string-length old))
|
|
(string-append new (string (string-ref old 0)))))))))
|
|
|
|
(define (get-next-word-braces str)
|
|
(let loop ((old str)
|
|
(new ""))
|
|
(if (= 0 (string-length old))
|
|
(cons new old)
|
|
(if (char=? #\( (string-ref old 0))
|
|
(let* ((nw (get-next-word-braces
|
|
(substring old 1
|
|
(string-length old))))
|
|
(nw-new (car nw))
|
|
(nw-old (cdr nw)))
|
|
(loop nw-old (string-append new "(" nw-new)))
|
|
(if (char=? #\) (string-ref old 0))
|
|
(cons (string-append new ")")
|
|
(substring old 1 (string-length old)))
|
|
(loop (substring old 1 (string-length old))
|
|
(string-append new (string (string-ref old 0)))))))))
|
|
|
|
;;scroll buffer after one command was entered
|
|
(define (scroll-command-buffer)
|
|
(set-buffer-pos-line! command-buffer
|
|
(+ (buffer-pos-line command-buffer) 1))
|
|
(set-buffer-pos-col! command-buffer 2))
|
|
|
|
;;evaluate an expression given as a string
|
|
(define (evaluate exp)
|
|
(let* ((command-port (open-input-string exp))
|
|
(handler (lambda (condition more)
|
|
(cons 'Error: condition)))
|
|
(structure (reify-structure 'scheme-with-scsh))
|
|
(s (load-structure structure))
|
|
(env (rt-structure->environment structure))
|
|
(result (with-fatal-error-handler
|
|
handler
|
|
(eval (read command-port) env))))
|
|
result))
|
|
|
|
;;Message-Passing
|
|
;;switch manages that the messages are delivered in the correct way
|
|
(define (switch message)
|
|
(let ((command ""))
|
|
(cond
|
|
((next-command-message? message)
|
|
(set! command (next-command-string message)))
|
|
((key-pressed-message? message)
|
|
(set! command (key-pressed-command-string message)))
|
|
((print-message? message)
|
|
(set! command (print-message-command-string message)))
|
|
((restore-message? message)
|
|
(set! command (restore-message-command-string message)))
|
|
((selection-message? message)
|
|
(set! command (selection-message-command-string message))))
|
|
(let ((receiver (get-receiver command)))
|
|
(if receiver
|
|
(receiver message)
|
|
(standard-receiver message)))))
|
|
|
|
(define (get-receiver command)
|
|
(let loop ((recs receivers))
|
|
(if (= 0 (length recs))
|
|
#f
|
|
(let* ((act-rec (car recs))
|
|
(act-com (receiver-command act-rec))
|
|
(act-rec-proc (receiver-rec act-rec)))
|
|
(if (equal? command act-com)
|
|
act-rec-proc
|
|
(loop (cdr recs)))))))
|
|
|
|
;;Management of the upper buffer
|
|
;;add a char to the buffer
|
|
(define (add-to-command-buffer ch)
|
|
(let* ((text (buffer-text command-buffer))
|
|
(last-pos (- (length text) 1))
|
|
(old-last-el (list-ref text last-pos))
|
|
(old-rest (sublist text 0 last-pos))
|
|
(before-ch (substring old-last-el 0
|
|
(max 0 (- (buffer-pos-col command-buffer) 2))))
|
|
(after-ch (substring old-last-el
|
|
(max 0 (- (buffer-pos-col command-buffer) 2))
|
|
(string-length old-last-el)))
|
|
(new-last-el (string-append before-ch
|
|
(string (ascii->char ch))
|
|
after-ch)))
|
|
(set-buffer-text! command-buffer
|
|
(append old-rest (list new-last-el)))
|
|
(set-buffer-pos-col! command-buffer
|
|
(+ (buffer-pos-col command-buffer) 1))))
|
|
|
|
;;add a string to the buffer
|
|
(define (add-string-to-command-buffer string)
|
|
(let loop ((str string))
|
|
(if (string=? str "")
|
|
(values)
|
|
(let ((first-ch (string-ref str 0)))
|
|
(add-to-command-buffer (char->ascii first-ch))
|
|
(loop (substring str 1 (string-length str)))))))
|
|
|
|
|
|
;;selection of the visible area of the buffer
|
|
(define (prepare-lines l height pos)
|
|
(if (< (length l) height)
|
|
(let loop ((tmp-list l))
|
|
(if (= height (length tmp-list))
|
|
tmp-list
|
|
(loop (append tmp-list (list "")))))
|
|
(if (< pos height)
|
|
(sublist l 0 height)
|
|
(sublist l (- pos height) height))))
|
|
|
|
;;print the active-command window:
|
|
(define (print-active-command-win win width)
|
|
(if (<= width 25)
|
|
(values)
|
|
(let ((active-command (string-append active-command
|
|
active-parameters)))
|
|
(if (> (string-length active-command) (- width 25))
|
|
(let* ((com-txt (substring active-command
|
|
0
|
|
(- width 25)))
|
|
(whole-text (string-append "Active Command: "
|
|
com-txt
|
|
"...")))
|
|
(mvwaddstr win 1 2 whole-text)
|
|
(wrefresh win))
|
|
(begin
|
|
(mvwaddstr win 1 2 (string-append "Active Command: "
|
|
active-command))
|
|
(wrefresh win))))))
|
|
|
|
;;print the lower window
|
|
(define (print-result-buffer result-window)
|
|
(let* ((window (app-window-curses-win result-window))
|
|
(print-message (make-print-message active-command
|
|
current-result-object
|
|
(buffer-num-cols command-buffer)))
|
|
(model (switch print-message))
|
|
(text (print-object-text model))
|
|
(pos-y (print-object-pos-y model))
|
|
(pos-x (print-object-pos-x model))
|
|
(highlighted-lns (print-object-highlighted-lines model))
|
|
(marked-lns (print-object-marked-lines model)))
|
|
(set! text-result text)
|
|
(set! pos-result pos-y)
|
|
(set! pos-result-col pos-x)
|
|
(set! highlighted-lines highlighted-lns)
|
|
(set! marked-lines marked-lns)
|
|
(right-highlighted-lines)
|
|
(right-marked-lines)
|
|
(let ((lines (get-right-result-lines)))
|
|
(let loop ((pos 1))
|
|
(if (> pos result-lines)
|
|
(values)
|
|
(let ((line (list-ref lines (- pos 1))))
|
|
(begin
|
|
(if (not (standard-result-obj? current-result-object))
|
|
(set! line
|
|
(if (> (string-length line) result-cols)
|
|
(let ((start-line
|
|
(substring line 0
|
|
(- (ceiling (/ result-cols 2))
|
|
3)))
|
|
(end-line
|
|
(substring line
|
|
(- (string-length line)
|
|
(ceiling
|
|
(/ result-cols 2)))
|
|
(string-length line))))
|
|
(string-append start-line "..." end-line))
|
|
line)))
|
|
(if (and (member pos highlighted-lines)
|
|
(focus-on-result-buffer?))
|
|
(begin
|
|
(wattron window (A-REVERSE))
|
|
(mvwaddstr window pos 1 line)
|
|
(wattrset window (A-NORMAL))
|
|
(wrefresh window)
|
|
(loop (+ pos 1)))
|
|
(if (member pos marked-lines)
|
|
(begin
|
|
(wattron window (A-BOLD))
|
|
(mvwaddstr window pos 1 line)
|
|
(wattrset window (A-NORMAL))
|
|
(wrefresh window)
|
|
(loop (+ pos 1)))
|
|
(begin
|
|
(mvwaddstr window pos 1 line)
|
|
(wrefresh window)
|
|
(loop (+ pos 1))))))))))))
|
|
|
|
;;visible lines
|
|
(define (get-right-result-lines)
|
|
(prepare-lines text-result result-lines pos-result))
|
|
|
|
;;marked and highlighted lines
|
|
(define (right-highlighted-lines)
|
|
(let loop ((old highlighted-lines)
|
|
(new '()))
|
|
(if (null? old)
|
|
(set! highlighted-lines new)
|
|
(let ((el (car old)))
|
|
(if (<= pos-result result-lines)
|
|
;;auf der ersten Seite
|
|
(loop (cdr old)
|
|
(append new (list el)))
|
|
(let* ((offset (- pos-result result-lines))
|
|
(new-el (- el offset )))
|
|
(loop (cdr old)
|
|
(append new (list new-el)))))))))
|
|
|
|
(define (right-marked-lines)
|
|
(let loop ((old marked-lines)
|
|
(new '()))
|
|
(if (null? old)
|
|
(set! marked-lines new)
|
|
(let ((el (car old)))
|
|
(if (<= pos-result result-lines)
|
|
;;auf der ersten Seite
|
|
(loop (cdr old)
|
|
(append new (list el)))
|
|
(let* ((offset (- pos-result result-lines))
|
|
(new-el (- el offset )))
|
|
(loop (cdr old)
|
|
(append new (list new-el)))))))))
|
|
|
|
;;Cursor
|
|
;;move cursor to the corrct position
|
|
(define (move-cursor buffer)
|
|
(if (focus-on-command-buffer?)
|
|
(cursor-right-pos (app-window-curses-win command-window)
|
|
buffer)
|
|
(begin
|
|
(compute-y-x)
|
|
(wmove (app-window-curses-win result-window)
|
|
result-buffer-pos-y result-buffer-pos-x)
|
|
(wrefresh (app-window-curses-win result-window))
|
|
buffer)))
|
|
|
|
;;compue pos-x and pos-y
|
|
(define (compute-y-x)
|
|
(if (focus-on-command-buffer?)
|
|
(begin
|
|
(if (>= (buffer-pos-fin-ln command-buffer)
|
|
(buffer-num-lines command-buffer))
|
|
(set-buffer-pos-y! command-buffer
|
|
(buffer-num-lines command-buffer))
|
|
(set-buffer-pos-y! command-buffer
|
|
(buffer-pos-fin-ln command-buffer)))
|
|
(let ((posx (modulo (buffer-pos-col command-buffer)
|
|
(buffer-num-cols command-buffer))))
|
|
(set-buffer-pos-x! command-buffer posx)))
|
|
(begin
|
|
(if (>= pos-result result-lines)
|
|
(set! result-buffer-pos-y result-lines)
|
|
(set! result-buffer-pos-y pos-result))
|
|
(set! result-buffer-pos-x pos-result-col))))
|
|
|
|
|
|
; ;;index of shortcuts at the bottom
|
|
; (define print-bar3
|
|
; (lambda (width)
|
|
; (let loop ((pos 0)
|
|
; (used-width 0)
|
|
; (act-line 1))
|
|
; (if (>= pos (length shortcuts))
|
|
; (begin
|
|
; (let* ((num-blanks (+ (- width used-width) 1))
|
|
; (last-string (make-string num-blanks #\space)))
|
|
; (mvwaddstr bar3 act-line (+ used-width 1) last-string))
|
|
; (wrefresh bar3))
|
|
; (let* ((act-string (list-ref shortcuts pos))
|
|
; (act-length (string-length act-string))
|
|
; (rest-width (- width used-width)))
|
|
; (if (= act-line 1)
|
|
; (if (<= (+ act-length 3) rest-width)
|
|
; (if (= used-width 0)
|
|
; (begin
|
|
; (mvwaddstr bar3 1 (+ used-width 1) act-string)
|
|
; (loop (+ pos 1) (+ used-width act-length) 1))
|
|
; (begin
|
|
; (mvwaddstr bar3 1 (+ used-width 1)
|
|
; (string-append " | " act-string))
|
|
; (loop (+ pos 1) (+ used-width (+ 3 act-length))
|
|
; 1)))
|
|
; (begin
|
|
; (let* ((num-blanks (+ rest-width 1))
|
|
; (last-string (make-string num-blanks #\space)))
|
|
; (mvwaddstr bar3 1 (+ used-width 1) last-string))
|
|
; (loop pos 0 2)))
|
|
; (if (<= (+ act-length 3) rest-width)
|
|
; (if (= used-width 0)
|
|
; (begin
|
|
; (mvwaddstr bar3 2 (+ used-width 1) act-string)
|
|
; (loop (+ pos 1) (+ used-width act-length) 2))
|
|
; (begin
|
|
; (mvwaddstr bar3 2 (+ used-width 1)
|
|
; (string-append " | " act-string))
|
|
; (loop (+ pos 1) (+ used-width (+ 3 act-length)) 2)))
|
|
; (begin
|
|
; (let* ((num-blanks (+ rest-width 1) )
|
|
; (last-string (make-string num-blanks #\space)))
|
|
; (mvwaddstr bar3 2 (+ used-width 1) last-string))
|
|
; (wrefresh bar3)))))))))
|
|
|
|
|
|
|
|
;; one step back in the history
|
|
(define (history-back)
|
|
(if (<= history-pos 0)
|
|
(values)
|
|
(let* ((hist-entry (list-ref history (- history-pos 1)))
|
|
(entry-com (history-entry-command hist-entry))
|
|
(entry-par (history-entry-parameters hist-entry))
|
|
(entry-res-obj (history-entry-result-object hist-entry)))
|
|
(set! active-command entry-com)
|
|
(set! active-parameters entry-par)
|
|
(set! current-result-object entry-res-obj)
|
|
(if (> history-pos 1)
|
|
(set! history-pos (- history-pos 1))))))
|
|
|
|
;;one step forward
|
|
(define (history-forward)
|
|
(if (> history-pos (- (length history) 1))
|
|
(values)
|
|
(let* ((hist-entry (list-ref history history-pos))
|
|
(entry-com (history-entry-command hist-entry))
|
|
(entry-par (history-entry-parameters hist-entry))
|
|
(entry-res-obj (history-entry-result-object hist-entry)))
|
|
(set! active-command entry-com)
|
|
(set! active-parameters entry-par)
|
|
(set! current-result-object entry-res-obj)
|
|
(set! history-pos (+ history-pos 1)))))
|
|
|
|
(define (sublist l pos k)
|
|
(let ((tmp (list-tail l pos)))
|
|
(reverse (list-tail (reverse tmp)
|
|
(- (length tmp) k)))))
|
|
|
|
;;When NUIT is closed the state has to be restored, in order to let the
|
|
;;user start again from scratch
|
|
(define (restore-state)
|
|
(set! text-result (list "Start entering commands."))
|
|
(set! pos-result 0)
|
|
(set! pos-result-col 0)
|
|
(set! result-buffer-pos-y 0)
|
|
(set! result-buffer-pos-x 0)
|
|
(set! result-lines 0)
|
|
(set! result-cols 0)
|
|
(set! highlighted-lines '())
|
|
(set! marked-lines '())
|
|
(set! history '())
|
|
(set! history-pos 0)
|
|
(set! active-command "")
|
|
(set! active-parameters "")
|
|
(set! current-result-object init-std-res)
|
|
(set! active-keyboard-interrupt #f))
|
|
|
|
;;Shortcuts-receiver:
|
|
;;-------------------
|
|
;;If the user enters the command "shortcuts" a list of the included
|
|
;;shortcuts is displayed
|
|
(define-record-type shortcut-result-obj shortcut-result-obj
|
|
(make-shortcut-result-obj a)
|
|
shortcut-result-object?
|
|
(a shortcut-result-object-a))
|
|
|
|
(define (shortcut-receiver message)
|
|
(cond
|
|
((next-command-message? message)
|
|
(make-shortcut-result-obj #t))
|
|
((print-message? message)
|
|
(make-print-object 1 1 shortcuts '() '()))
|
|
((key-pressed-message? message)
|
|
(key-pressed-message-result-model message))
|
|
((restore-message? message)
|
|
(values))
|
|
((selection-message? message)
|
|
"")))
|
|
|
|
(define shortcut-rec (make-receiver "shortcuts" shortcut-receiver))
|
|
|
|
(set! receivers (cons shortcut-rec receivers))
|
|
|
|
|
|
|
|
;;Standard-Receiver
|
|
;;-----------------
|
|
|
|
;;Datatype representing the "standard-result-objects"
|
|
(define-record-type standard-result-obj standard-result-obj
|
|
(make-standard-result-obj cursor-pos-y
|
|
cursor-pos-x
|
|
result-text
|
|
result)
|
|
standard-result-obj?
|
|
(cursor-pos-y standard-result-obj-cur-pos-y)
|
|
(cursor-pos-x standard-result-obj-cur-pos-x)
|
|
(result-text standard-result-obj-result-text)
|
|
(result standard-result-obj-result))
|
|
|
|
(define init-std-res (make-standard-result-obj 1 1 text-result
|
|
(car text-result)))
|
|
|
|
(set! current-result-object init-std-res)
|
|
|
|
|
|
;;Standard-Receiver:
|
|
(define (standard-receiver message)
|
|
(cond
|
|
((next-command-message? message)
|
|
(let* ((command (next-command-string message))
|
|
(result (evaluate command))
|
|
(result-string (exp->string result))
|
|
(width (next-command-message-width message)))
|
|
(let* ((text
|
|
(layout-result-standard result-string result width))
|
|
(std-obj
|
|
(make-standard-result-obj 1 1 text result)))
|
|
std-obj)))
|
|
((print-message? message)
|
|
(let* ((model (print-message-object message))
|
|
(pos-y (standard-result-obj-cur-pos-y model))
|
|
(pos-x (standard-result-obj-cur-pos-x model))
|
|
(width (print-message-width message))
|
|
(result (standard-result-obj-result model))
|
|
(text (layout-result-standard (exp->string result)
|
|
result width)))
|
|
(make-print-object pos-y pos-x text '() '())))
|
|
((key-pressed-message? message)
|
|
(key-pressed-message-result-model message))
|
|
((restore-message? message)
|
|
(values))
|
|
((selection-message? message)
|
|
"")))
|
|
|
|
;;the result is the "answer" of scsh
|
|
(define (layout-result-standard result-str result width)
|
|
(reverse (seperate-line result-str width)))
|
|
|
|
;useful helpers
|
|
(define (get-marked-positions-1 all-items marked-items)
|
|
(let loop ((count 0)
|
|
(result '()))
|
|
(if (>= count (length all-items))
|
|
result
|
|
(let ((act-item (list-ref all-items count)))
|
|
(if (member act-item marked-items)
|
|
(loop (+ count 1)
|
|
(append result (list (+ count 1))))
|
|
(loop (+ count 1) result))))))
|
|
|
|
(define (get-marked-positions-2 all-items marked-items)
|
|
(let loop ((count 0)
|
|
(result '()))
|
|
(if (>= count (length all-items))
|
|
result
|
|
(let ((act-item (list-ref all-items count)))
|
|
(if (member act-item marked-items)
|
|
(loop (+ count 1)
|
|
(append result (list (+ count 2))))
|
|
(loop (+ count 1) result))))))
|
|
|
|
(define (get-marked-positions-3 all-items marked-items)
|
|
(let loop ((count 0)
|
|
(result '()))
|
|
(if (>= count (length all-items))
|
|
result
|
|
(let ((act-item (list-ref all-items count)))
|
|
(if (member act-item marked-items)
|
|
(loop (+ count 1)
|
|
(append result (list (+ count 3))))
|
|
(loop (+ count 1) result))))))
|
|
|
|
;;expression as string
|
|
(define (exp->string exp)
|
|
(let ((exp-port (open-output-string)))
|
|
(write exp exp-port)
|
|
(get-output-string exp-port)))
|
|
|
|
;;seperate a long line into pieces, each fitting into a smaller line.
|
|
(define (seperate-line line width)
|
|
(let loop ((new '())
|
|
(old line))
|
|
(if (> width (string-length old))
|
|
(if (= 0 (string-length old))
|
|
(if (equal? new '())
|
|
'("")
|
|
new)
|
|
(append (list old) new))
|
|
(let ((next-line (substring old 0 width))
|
|
(rest-old (substring old width (string-length old))))
|
|
(loop (cons next-line new) rest-old)))))
|
|
|
|
(define (get-param-as-str param-lst)
|
|
(let loop ((lst param-lst)
|
|
(str ""))
|
|
(if (null? lst)
|
|
str
|
|
(loop (cdr lst)
|
|
(string-append str " " (car lst))))))
|