"

 COPYRIGHT (c) 1993 by Claus Gittinger

	      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.

"

Object subclass:#WindowSensor

	instanceVariableNames:'eventSemaphore damage mouseAndKeyboard compressMotionEvents

		ignoreUserInput exposeEventSemaphore catchExpose gotExpose

		gotOtherEvent translateKeyboardEvents shiftDown ctrlDown metaDown

		altDown leftButtonDown middleButtonDown rightButtonDown

		eventListener keyboardListener'

	classVariableNames:'ControlCEnabled EventListener ComposeTable GotCompose Compose1'

	poolDictionaries:''

	category:'Interface-Support'

!

!WindowSensor class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1993 by Claus Gittinger

	      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

"

    Instances of this class keep track of events and damage areas for a group of 

    views. All incoming expose rectangles and events (from Workstation) are 

    collected here, until someone (usually the windowGroup process)

    gets a chance to handle them. 

    In contrast to ST-80 (which has one windowSensor per window), ST/X usually

    only assigns one sensor per windowGroup.

    (however, you could manually arrange for per view private sensors

     - at least, theoretically)

    When adding an expose rectangle, WindowSensor tries to merge the rectangle 

    with the list of existing damages to minimize redrawing.

    Processing of compose key sequences is done here; if a Compose

    key event arrives, the following 2 characters are used to search an

    entry in the composeTable, and are replaced by the character found there.

    For example, pressing Compose-a-` gives the french a-accent-grave character;

    pressing Compose-a-e gives the ae ligature.

    Beside the above, windowSensors provide facilities (hooks) to allow

    a so-called 'eventListener' to get the event before it is entered into

    the queue. There are 3 possible listening hooks available:

	a global EventListener - gets keybd/mouse events for all views

	a per-sensor eventListener - gets only keybd/mouse events for this sensors wGroup

	a per-sensor keyboardListener - only gets keyboard events for this sensors wGroup

    (actually, there are two more mechanisms, event delegation which allows

     delegation of key- and buttonEvents of a specific view,

     and per-windowGroup eventHooks)

    The global eventListener is installed via a class method (eventListener:) to

    the WindowSensor class; local listeners are installed via instance methods.

    Each listener should return true, if it handled the event and that event should

    therefore NOT be enqueued. Likewise, if it returns false, the event is

    processed as usual (i.e. enqueued and forwarded to the views controller).

    The global listener is called before the local listener, which is called

    before the keyboard listener. If any returns true, later listeners wont get

    the event.

    EventListeners were added to allow the implementation of event recorders

    or other spy functionality. They also allow hooking up views which otherwise

    insist on doing things themself.

    Notice, that beside event listening, you can also define a delegate for

    a views keyboard and button events. 

    Read the documentation in WindowEvent for more info.

    instance variables:

	eventSemaphore          <Semaphore>     the semaphore to be signalled when an event

						(or damage) arrives

	damage                  <Collection>    collection of damage events

	mouseAndKeyboard        <Collection>    collection of user events

	compressMotionEvents    <Boolean>       if true, multiple motion events are

						compressed to one event. If false, each

						event is handled individual.

						(should be set to false when doing free-hand drawing)

	ignoreUserInput         <Boolean>       if true, key & button events are ignored

						(usually set to true by WindowGroup, while a

						 modalbox covers a view)

	shiftDown               <Boolean>       true while shift/meta/control-key is pressed

	metaDown                                (to support ST-80 style query: sensor shiftDown)

	ctrlDown

	altDown                                 (notice, that on most systems, alt and meta key is

						 the same, both reported as #Alt)

	exposeEventSemaphore    <Semaphore>     X-special: semaphore to be signalled when

						expose event arrives after a copyArea.

	catchExpose             <Boolean>       true, while waiting for an expose event 

						(after a copyArea)

	gotExpose               <Boolean>       set to true, when an expose event arrives

						(after a copyarea)

	gotOtherEvent           <Boolean>       set to true if other events arrive while

						waiting for expose (after a copyarea).

	translateKeyboardEvents <Boolean>       if true, keyboard events are translated via

						the devices leyboardMap; if false, they

						are reported as raw-keys. Default is true.

	eventListener           <Object>        if non nil, this one will get all pointer

						and keyboard events for this sensors views first.

						If it returns true, the event is supposed to

						be already handled by the listener and not sent to

						the view. If false, the event is handled as usual.

						This allows applications to catch events for any of

						its views.

	keyboardListener        <Object>        if non nil, this one will get all keyboard events 

						for this sensors views first (but after the eventListener,

						if any).

						If it returns true, the event is supposed to

						be already handled by the listener and not sent to

						the view. If false, the event is handled as usual.

						This allows applications to catch events for any of

						its views.

						ApplicationModels can catch keyboard input with:

						    postOpenWith:aBuilder

							aBuilder window sensor keyboardListener:self

    class variables:

	ControlCEnabled         <Boolean>       if true (which is the default) Control-C

						will interrupt the process handling the

						view.

						For secure stand-alone applications,

						this can be set to false, in which case 

						Control-C does NOT interrupt the process.

	EventListener           <Object>        if non nil, this one will get all pointer

						and keyboard events for ALL views first.

						If it returns true, the event is supposed to

						be already handled by the listener and not enqueued. 

						If false, the event is handled as usual.

						This allows overall event catchers to be

						installed for example to implement event

						recorders, active help managers etc.

	ComposeTable            <Array>         compose-key translation table

"

! !

!WindowSensor class methodsFor:'initialization'!

initialize

    ControlCEnabled := true.

    ComposeTable isNil ifTrue:[

	ComposeTable := #(

	    "/ key1 key2 -> character or asciiValue

	    ($+ $+ $#)         "/ number-sign

	    ($A $A $@)         "/ at-sign

	    ($( $- ${)         "/ left brace

	    ($) $- $})         "/ right brace

	    ($| $c 16rA2)      "/ cent-sign 

	    ($| $S $$)         "/ dollar-sign

	    ($= $L 16rA3)      "/ pound-sign     

	    ($= $Y 16rA5)      "/ yen-sign        

	    ($!! $s 16rA7)      "/ section-sign    

	    ($O $C 16rA9)      "/ copyright        

	    ($< $< 16rAB)      "/ french <<-quotes 

	    ($O $R 16rAE)      "/ registered       

	    ($/ $u 16rB5)      "/ greek mu         

	    ($!! $p 16rB6)      "/ paragraph sign   

	    ($> $> 16rBB)      "/ french >> quotes 

	    ($^ $0 16rB0)      "/ degree sign      

	    ($+ $- 16rB1)      "/ plus-minus       

	    ($^ $2 16rB2)      "/ superscript-2    

	    ($^ $3 16rB3)      "/ superscript-3    

"/            ($. $^ 16rB7)      "/ middle dot       

	    ($^ $. 16rB7)      "/ middle dot       

	    ($^ $1 16rB9)      "/ superscript-1    

	    ($1 $4 16rBC)      "/ 1/4              

	    ($1 $2 16rBD)      "/ 1/2              

	    ($3 $4 16rBE)      "/ 3/4              

	    ($? $? 16rBF)      "/ ?-inverted       

	    ($- $: 16rF7)      "/ divide           

	    "/ diacriticals: Compose diacrit character

	    "/ grave

	    ($A $` 16rC0)      "/ A-`              

	    ($a $` 16rE0)      "/ a-`              

	    ($E $` 16rC8)      "/ E-`              

	    ($e $` 16rE8)      "/ e-`              

	    ($I $` 16rCC)      "/ I-`              

	    ($i $` 16rEC)      "/ i-`              

	    ($O $` 16rD2)      "/ O-`              

	    ($o $` 16rF2)      "/ o-`              

	    ($U $` 16rD9)      "/ U-`              

	    ($u $` 16rF9)      "/ u-`              

	    "/ acute

	    ($A $' 16rC1)      "/ A-'             

	    ($a $' 16rE1)      "/ a-'             

	    ($E $' 16rC9)      "/ E-'            

	    ($e $' 16rE9)      "/ e-'           

	    ($I $' 16rCD)      "/ I-'          

	    ($i $' 16rED)      "/ i-'         

	    ($O $' 16rD3)      "/ O-'        

	    ($o $' 16rF3)      "/ o-'       

	    ($U $' 16rDA)      "/ U-'      

	    ($u $' 16rFA)      "/ u-'     

	    ($Y $' 16rDD)      "/ Y-'    

	    ($y $' 16rFD)      "/ y-'   

	    "/ circumflex

	    ($A $^ 16rC2)      "/ A-^              

	    ($a $^ 16rE2)      "/ a-^             

	    ($E $^ 16rCA)      "/ E-^            

	    ($e $^ 16rEA)      "/ e-^           

	    ($I $^ 16rCE)      "/ I-^          

	    ($i $^ 16rEE)      "/ i-^         

	    ($O $^ 16rD4)      "/ O-^        

	    ($o $^ 16rF4)      "/ o-^       

	    ($U $^ 16rDB)      "/ U-^      

	    ($u $^ 16rFB)      "/ u-^     

	    "/ tilde

	    ($A $~ 16rC3)      "/ A-~              

	    ($a $~ 16rE3)      "/ a-~             

	    ($O $~ 16rD5)      "/ O-~            

	    ($o $~ 16rF5)      "/ o-~           

	    ($N $~ 16rD1)      "/ N-tilde      

	    ($n $~ 16rF1)      "/ n-~         

	    "/ ring above

	    ($a $* 16rE5)      "/ a-*              

	    ($A $* 16rC5)      "/ A-*             

	    "/ cedille

	    ($C $, 16rC7)      "/ C-,              

	    ($c $, 16rE7)      "/ c-,             

	    "/ dieresis

	    ($A $" 16rC4)      "/ A-"              

	    ($a $" 16rE4)      "/ a-"             

	    ($E $" 16rCB)      "/ E-"            

	    ($e $" 16rEB)      "/ e-"           

	    ($I $" 16rCF)      "/ I-"          

	    ($i $" 16rEF)      "/ i-"         

	    ($O $" 16rD6)      "/ O-"        

	    ($o $" 16rF6)      "/ o-"       

	    ($U $" 16rDC)      "/ U-"      

	    ($u $" 16rFC)      "/ u-"     

	    ($y $" 16rFF)      "/ y-"    

	    "/ ligatures

	    ($s $s 16rDF)      "/ german sz        

	    ($a $e 16rE6)      "/ (french) ae     

	    ($A $E 16rC6)      "/ (french) AE    

	).

    ]

    "

     WindowSensor initialize

    "

! !

!WindowSensor class methodsFor:'instance creation'!

new

    ^ self basicNew initialize

! !

!WindowSensor class methodsFor:'accessing'!

composeTable

    "return the compose-key table.

     Entries consist of 3-element arrays each, where

     the first two entries (of each entry) are the raw characters,

     and the third is the resulting composed-key"

    ^ ComposeTable

!

composeTable:aTable

    "set the compose-key table.

     Entries consist of 3-element arrays each, where

     the first two entries (of each entry) are the raw characters,

     and the third is the resulting composed-key"

    ComposeTable := aTable

!

controlCEnabled:aBoolean

    "enable/disable Control-C processing. 

     If enabled, pressing CNTL-C in a view will interrupt it and bring

     its process into the debugger (actually raising signal).

     Otherwise, CNTL-C is sent to the view like any other key.

     The default is true (enabled).

    "

    ControlCEnabled := aBoolean

!

eventListener

    "return the eventListener 

     - see documentation for what this can be used for"

    ^ EventListener

!

eventListener:aListener

    "set the eventListener 

     - see documentation for what this can be used for"

    EventListener := aListener

! !

!WindowSensor class methodsFor:'queries'!

cursorPoint

    "ST-80 compatibility: 

     return the position of the cursor on the current display"

    ^ Screen current pointerPosition

    "

     WindowSensor cursorPoint

    "

! !

!WindowSensor methodsFor:'accessing'!

compressMotionEvents:aBoolean

    "turn on/off motion event compression"

    compressMotionEvents := aBoolean

!

eventListener

    "return the eventListener 

     - see documentation for what this can be used for"

    ^ eventListener

!

eventListener:aListener

    "set the eventListener 

     - see documentation for what this can be used for"

    eventListener := aListener

!

eventSemaphore

    "return the semaphore used to signal event arrival"

    ^ eventSemaphore

!

eventSemaphore:aSemaphore

    "set the semaphore used to signal event arrival"

    eventSemaphore := aSemaphore

!

ignoreUserInput

    "return true, if Ctrl-C processing is currently turned off"

    ^ ignoreUserInput

!

ignoreUserInput:aBoolean

    "turn on/off ignoring of Ctrl-C processing"

    ignoreUserInput := aBoolean

!

keyboardListener

    "return the keyboardListener 

     - see documentation for what this can be used for"

    ^ keyboardListener

!

keyboardListener:aListener

    "set the keyboardListener 

     - see documentation for what this can be used for"

    keyboardListener := aListener

! !

!WindowSensor methodsFor:'event flushing'!

compressKeyPressEventsWithKey:aKey

    "count and remove multiple pending keyPress events for the

     same key, aKey. This is currently used in TextViews to compress

     multiple cursorUp/cursorDown events and do the scroll in one

     operation. (to avoid run-after-cursor on slow displays)"

    |n ev|

    n := 0.

    ev := self pendingEvent.

    [ev notNil and:[ev isKeyPressEvent]] whileTrue:[

	((ev arguments at:1) == aKey) ifTrue:[

	    n := n + 1.

	    self nextEvent.

	    ev := self pendingEvent.

	] ifFalse:[

	    ev := nil

	]

    ].

    ^ n

!

flushEventsFor:aView

    "throw away all events for aView, 

     or any view, if the argument is nil."

    self flushExposeEventsFor:aView.

    self flushUserEventsFor:aView.

!

flushExposeEvents

    "throw away all pending expose events; this

     can be done after a full redraw (or in views, which are

     doing full redraws anly)"

    (damage isNil or:[damage size > 0]) ifTrue:[

	damage := OrderedCollection new

    ].

!

flushExposeEventsFor:aView

    "throw away all pending expose events for aView, 

     or any view, if the argument is nil. 

     This can be done after a full redraw 

     (or in views, which are always doing full redraws -

      instead of drawing the clip-area only)"

    |nEvent "{ Class: SmallInteger }"|

    damage notNil ifTrue:[

	nEvent := damage size.

	1 to:nEvent do:[:index |

	    |aDamage|

	    aDamage := damage at:index.

	    aDamage notNil ifTrue:[

		(aView isNil or:[aDamage view == aView]) ifTrue:[

		    damage at:index put:nil

		]

	    ]

	]

    ].

!

flushKeyboard

    "ST-80 compatibility: throw away all pending keyboard events"

    self flushKeyboardFor:nil

!