"

 COPYRIGHT (c) 1998 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libwidg2' }"

TextCollector subclass:#TerminalView

	instanceVariableNames:'inStream outStream readerProcess shellPid kbdSequences

		escapeSequenceTree currentSequence kbdMap escapeLeadingChars

		numberOfColumns numberOfLines shellTerminateAction rangeStartLine

		rangeEndLine state savedCursor shellCommand shellDirectory

	classVariableNames:''

	poolDictionaries:''

	category:'Views-TerminalViews'

!

!TerminalView class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1998 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    I provide terminal functionality, by interpreting data

    arriving from some stream (typically connected to a command interpreter 

    via a pty, or another system via a modem) 

    and sending my keyboard data to it.

    I am abstract providing general functionality

    - concrete terminal characteristics are defined by concrete subclasses 

    (see VT52TerminalView, VT100TerminalView).

    Concrete applications are: 

        consoles (VT100TerminalView),

        telnet-views (see TelnetTool)

        editor wrappers (if you like emacs/vi)

    <<although my class protocol includes common startup protocol

    (to open a terminalView with a shell or on the output of a command),

    I can be used as a widget within an application (Modem software).

    [author:]

        Claus Gittinger

    [instance variables:]

        inStream                stream where keyboard input is

                                sent to (connected to shells or commands input)

        outStream               stream where the output of the

                                shell or command arrives

                                (read here and displayed in the view)

        readerProcess           process which reads commands    

                                output and sends it to the view

    [start with:]

        VT52TerminalView open

        VT100TerminalView open

        VT52TerminalView openShell

        VT100TerminalView openShell

        VT100TerminalView openOnCommand:'ls -l'

        VT100TerminalView openOnCommand:'dir'

    [see also:]

        TelNetTool

"

! !

!TerminalView class methodsFor:'defaults'!

defaultIcon

    ^ Image fromFile:'bitmaps/xpmBitmaps/terminal_images/xterm-icon.xpm'

    "Created: / 4.8.1998 / 17:48:18 / cg"

    "Modified: / 4.8.1998 / 17:48:31 / cg"

!

defaultNumberOfColumns

    ^ 80

    "Created: / 4.8.1998 / 17:48:18 / cg"

    "Modified: / 4.8.1998 / 17:48:31 / cg"

!

defaultNumberOfLines

    ^ 25

    "Created: / 4.8.1998 / 17:48:18 / cg"

    "Modified: / 4.8.1998 / 17:48:31 / cg"

! !

!TerminalView class methodsFor:'opening'!

open

    ^ self openShell

    "

     VT100TerminalView open

    "

    "Created: / 10.6.1998 / 15:47:25 / cg"

    "Modified: / 9.7.1998 / 17:55:37 / cg"

!

openDummy

    "for testing purposes only - opens a dummy tty-view, which simply

     echoes whatever is typed in"

    |in vt52|

    vt52 := self new.

    in := ForwardingStream on:''.

    in fwdStream:vt52.

    vt52 inStream:in.

    vt52 outStream:in.

    vt52 open

    "

     self openDummy

    "

!

openOnCommand:aCommandString

    "start a command on a pseudo-TTY, open a terminalView on it

     (i.e. this is kind of an xterm)"

    ^ self openOnCommand:aCommandString onExit:[]

    "

     VT100TerminalView openOnCommand:'ls -l'

    "

    "Created: / 9.7.1998 / 17:50:53 / cg"

    "Modified: / 9.7.1998 / 17:57:41 / cg"

!

openOnCommand:aCommandString onExit:aBlock

    "start a command on a pseudo-TTY, open a terminalView on its output

     (i.e. this is kind of an xterm).

     When the command finishes, evaluate aBlock."

    |in top scr vt52|

    top := StandardSystemView new.

    scr := ScrollableView for:self in:top.

    scr origin:0.0@0.0 corner:1.0@1.0.

    vt52 := scr scrolledView.

    vt52 startCommand:aCommandString.

    vt52 shellTerminateAction:[

        top label:('finished: "' , aCommandString , '"'). aBlock value

    ].

    top extent:(scr preferredExtent).

    top label:('executing: "' , aCommandString , '"').

    top iconLabel:'command'.

    top icon:(self defaultIcon).

    top open.

    ^ vt52

    "

     VT100TerminalView openOnCommand:'ls -lR'

     VT100TerminalView openOnCommand:'vi /etc/hosts'

    "

    "Created: / 9.7.1998 / 17:54:34 / cg"

    "Modified: / 4.8.1998 / 17:49:02 / cg"

!

openOnInput:inStream output:outStream

    "open a terminalView on the given streams (which are typically some

     kind of socket or pty). 

     Keys pressed are sent to inStream, text appearing

     from outStream is displayed in the terminal view.

     This can be used to implement things like rlogin

     or telnet views (if connected to a modem, a com-program can also be

     implemented this way)."

    |in top scr vt|

    top := StandardSystemView new.

    scr := ScrollableView for:self in:top.

    scr origin:0.0@0.0 corner:1.0@1.0.

    vt := scr scrolledView.

    vt inStream:inStream.

    vt outStream:outStream.

    vt startReaderProcess.

    top extent:(scr preferredExtent).

    top label:'shell'.

    top iconLabel:'shell'.

    top icon:(self defaultIcon).

    top open.

    ^ top

    "Modified: / 5.5.1999 / 17:25:59 / cg"

!

openShell

    "start a shell on a pseudo-TTY, open a terminalView on it

     (i.e. this is kind of an xterm)"

    ^ self openShellIn:nil

    "

     VT100TerminalView openShell

    "

    "Modified: / 21.7.1998 / 18:24:55 / cg"

!

openShellIn:aDirectory

    "start a shell on a pseudo-TTY, open a terminalView on it

     (i.e. this is kind of an xterm)"

    |in top scr vt lbl|

    top := StandardSystemView new.

    scr := ScrollableView for:self in:top.

    scr origin:0.0@0.0 corner:1.0@1.0.

    vt := scr scrolledView.

    vt startShellIn:aDirectory.

    vt shellTerminateAction:[top destroy].

    lbl := OperatingSystem isUNIXlike ifTrue:['shell'] ifFalse:['dos'].

    top extent:(scr preferredExtent).

    top label:lbl.

    top iconLabel:lbl.

    top icon:(self defaultIcon).

    top open.

    ^ vt

    "

     VT100TerminalView openShellIn:'/etc'

    "

    "Created: / 20.7.1998 / 18:28:15 / cg"

    "Modified: / 5.5.1999 / 17:27:10 / cg"

! !

!TerminalView class methodsFor:'queries'!

isVisualStartable

    "returns whether this application class can be started via #open"

    self == TerminalView ifTrue:[^ false].

    ^ true

    "Created: / 10.6.1998 / 15:48:43 / cg"

! !

!TerminalView methodsFor:'accessing'!

inStream

    "return the value of the instance variable 'inStream' (automatically generated)"

    ^ inStream

!

inStream:something

    "set the value of the instance variable 'inStream' (automatically generated)"

    inStream := something.

!

localEcho:aBoolean

    "enable/disable local echo"

    localEcho := aBoolean

    "Created: / 5.5.1999 / 17:53:16 / cg"

!

outStream

    "return the value of the instance variable 'outStream' (automatically generated)"

    ^ outStream

!

outStream:something

    "set the value of the instance variable 'outStream' (automatically generated)"

    outStream := something.

!

readerProcess

    "return the value of the instance variable 'readerProcess' (automatically generated)"

    ^ readerProcess

!

shellTerminateAction:aBlock

    "set the block which is evaluated when the shell terminates.

     Can be used to close down the application in this case."

    shellTerminateAction := aBlock.

    "Created: / 12.6.1998 / 17:02:58 / cg"

! !

!TerminalView methodsFor:'cursor handling'!

cursorCol:col

    "check of col is a valid cursor position; return a new col-nr if not.

     Here, the linelength is enforced"

    ^ super cursorCol:(col min:numberOfColumns)

    "Modified: / 10.6.1998 / 15:09:34 / cg"

!

cursorDown:n

    cursorLine + n > list size ifTrue:[

        list := list , (Array new:n).

        self textChanged.

    ].

    super cursorDown:n

    "Modified: / 10.6.1998 / 17:18:41 / cg"

    "Created: / 10.6.1998 / 17:18:50 / cg"

!

cursorLine:l col:col

    "check of col is a valid cursor position; return a new col-nr if not.

     Here, the linelength is enforced"

    ^ super cursorLine:l col:(col min:numberOfColumns)

    "Modified: / 10.6.1998 / 15:09:38 / cg"

!

cursorMovementAllowed

    "return true, if the user may move the cursor around

     (via button-click, or cursor-key with selection).

     Here false is returned - the cursor is only moved by

     cursor positioning escape sequences arriving from the

     stream."

    ^ false

    "Created: / 18.6.1998 / 14:12:02 / cg"

!

numberOfTerminalColumns

    ^ numberOfColumns

    "Created: / 5.5.1999 / 11:46:25 / cg"

!

numberOfTerminalLines

    "/ be careful - this is NOT called numberOfLines,

    "/ since that would interfere with numberOfLines as defined

    "/ in ListView ...

    "/ ... one of the bad sides of subclassing

    ^ numberOfLines

    "Created: / 5.5.1999 / 11:46:18 / cg"

    "Modified: / 5.5.1999 / 11:47:24 / cg"

!

restoreCursor

    |l c|

    l := savedCursor y.

    c := savedCursor x.

    self cursorLine:l col:c.

    "Created: / 14.8.1998 / 13:49:24 / cg"

!

saveCursor

    savedCursor := cursorCol @ cursorLine

    "Created: / 14.8.1998 / 13:48:45 / cg"

    "Modified: / 14.8.1998 / 13:49:32 / cg"

!

validateCursorCol:col inLine:line

    "check of col is a valid cursor position; return a new col-nr if not.

     Here, the linelength is enforced"

    ^ col min:numberOfColumns

    "Modified: / 10.6.1998 / 15:09:41 / cg"

! !

!TerminalView methodsFor:'defaults'!

anyKeyCodes

    ^ IdentityDictionary withKeysAndValues:

        #(

             #Escape      '\e'

             #BackSpace   '\b'

             #Return      '\r'

             #Delete      '\0177'

             #Tab         '\t'

         )

    "Created: / 5.5.1999 / 15:00:37 / cg"

! !

!TerminalView methodsFor:'event handling'!

computeNumberOfLinesShown

    |prevNLines prevNCols|

    prevNCols := (innerWidth // font width).

    prevNLines := nFullLinesShown.

    super computeNumberOfLinesShown.

    ((innerWidth // font width) ~~ prevNCols

    or:[prevNLines ~~ nFullLinesShown]) ifTrue:[

        self defineWindowSize.

    ]

    "Created: / 12.6.1998 / 22:34:39 / cg"

    "Modified: / 20.6.1998 / 19:45:28 / cg"

!

contentsChanged

    super contentsChanged.

    self defineWindowSize.

    "Modified: / 11.6.1998 / 22:51:48 / cg"

    "Created: / 5.5.1999 / 16:30:15 / cg"

!

defineWindowSize

    |fd delta prevNumCols prevNumLines|

"/self halt.

"/self realized ifFalse:[

"/    "/ iconfified

"/    ^ self

"/].

    prevNumCols := numberOfColumns.