"

 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 ignoreExposeEvents accessLock'

	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             <SetOfView>     if nonEMpty, the drawables which wait for

						an expose/noExpose event.  (after a copyArea)

	gotExpose               <SetOfView>     the set of drawables which got an expose/noExpose

						event.  (after a copyarea)

	gotOtherEvent           <SetOfView>     set of drawables which received if other events,

						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

	accessLock              <Semaphore>     controls access to the event queues

    [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

    [author:]

	Claus Gittinger

    [see also:]

	WindowGroup 

	WindowEvent KeyboardMap KeyboardForwarder EventListener

	DeviceWorkstation View

"

! !

!WindowSensor class methodsFor:'initialization'!

initialize

    "initialize the classes constants"

    ControlCEnabled := true.

    ComposeTable isNil ifTrue:[

	self initializeComposeKeyTable

    ]

    "

     WindowSensor initialize

    "

    "Modified: 22.4.1996 / 16:19:24 / cg"

!

initializeComposeKeyTable

    "setup the composeKey table"

    ComposeTable := #(

	"/ format is:

	"/ ( 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       

	($^ $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-"    

	"/ slashed

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

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

	"/ ligatures

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

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

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

    ).

    "              

     WindowSensor initializeComposeKeyTable

    "

    "Created: 22.4.1996 / 14:06:43 / cg"

    "Modified: 24.4.1996 / 16:37:08 / cg"

! !

!WindowSensor class methodsFor:'instance creation'!

new

    "return a new initialized instance"

    ^ self basicNew initialize

    "Modified: 22.4.1996 / 16:19:40 / cg"

! !

!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 a UserInterrupt signal).

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

     The default is true (enabled).

     Be very careful - only disable CNTL-C handling for well-debugged

     applications ... however, even if disabled, there still is the CNTL-C

     key on the startup (x)-terminal window (which can also be disabled).

    "

    ControlCEnabled := aBoolean

    "Modified: / 29.10.1997 / 15:48:29 / cg"

!

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:'ST-80 compatibility'!

eventQuit:event

    "ST-80 compatibility:

     push an event for terminating the topViews application"

    ^ self pushEvent:(WindowEvent

                             for:nil

                             type:#quit)

    "Modified: 3.3.1997 / 20:15:00 / cg"

! !

!WindowSensor methodsFor:'accessing'!

compressMotionEvents:aBoolean

    "turn on/off motion event compression"

    compressMotionEvents := aBoolean

!

criticalEventQueueAccess:aBlock

    |wasBlocked|

    wasBlocked := Processor activeProcess blockInterrupts.

    [

        accessLock critical:aBlock

    ] valueNowOrOnUnwindDo:[

        wasBlocked ifFalse:[

            Processor activeProcess unblockInterrupts.

        ]

    ]

!

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

!

ignoreExposeEvents:aBoolean

    ignoreExposeEvents := aBoolean

    "Created: 21.5.1996 / 18:21:18 / cg"

!

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