"

 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:#WindowEvent

	instanceVariableNames:'view type arguments'

	classVariableNames:''

	poolDictionaries:''

	category:'Interface-Support'

!

WindowEvent subclass:#InputEvent

	instanceVariableNames:'modifierFlags'

	poolDictionaries:''

	privateIn:WindowEvent

!

WindowEvent subclass:#ClientEvent

	instanceVariableNames:'eventData'

	classVariableNames:''

	poolDictionaries:''

	privateIn:WindowEvent

!

WindowEvent::InputEvent subclass:#ButtonEvent

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:WindowEvent

!

WindowEvent::InputEvent subclass:#KeyboardEvent

	instanceVariableNames:'rawKey'

	classVariableNames:''

	poolDictionaries:''

	privateIn:WindowEvent

!

!WindowEvent 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 WindowEvent are created for every event coming from

    the graphics device. 

    Usually, they are enqueued by the event dispatcher process into

    a sensors input queue, and dequeued & processed by a windowGroup process

    in its event loop.

    WindowEvents hold the event type and additional information (such as key,

    x/y coordinates etc). Also, windowEvents know how to send themself to some

    destination. To provide a common (single) place where event dispatching is

    implemented, this forwarding is done by a class method here (i.e. not by the

    window group itself).

    The algorithm for event dispatching is:

        - if the destination view has a keyboard focus set,

          AND the event is a keyboard event,

          THEN recursively invoke the event dispatching method,

               sending the event to the focus view (or its delegate, as below)

        - if the destination view has a delegate,

          AND its a keyboard, button or pointer event,

          AND the delegate is interested in that event 

              (i.e. implements & responds to #handlesXXX with true)

          THEN send the event to the delegate, passing the original view

               as additional argument

        - if the view has a nonNil controller,

          AND its a key, button or pointer event,

          THEN send the event to the controller

        - otherwise send the event to the view

    If the view has a non-nil transformation, the event is sent as a

    #deviceXXX message, passing device coordinates. Typically, subclasses

    of view do not redefine this method and the inherited default method

    translates these device coordinates into logical coordinates and resends

    an XXX message.

    If the view has no transformation, the XXX message is directly sent here.

    For example, a 'buttonPress:button x:x y:y' event leads to sending of

    'aView deviceButtonPress:button x:x y:y' which resends

    'aView buttonPress:button x:(x-logical) y:(y-logical)'

    This allows views which are interested in deviceCoordinates to get them

    (by redefining #deviceXXX) and other views to transparently get & use

    logical coordinates.

    Therefore, for a delegated keyPress messages, the flow is:

        sendEvent

            view has delegate

                ------> ask delegate via 'handlesKeyPress:key inView:view'

                <------ returns true

                ------> 'delegate keyPress:key x:x y:y view:view'

                        -----> delegate does whatever it wants to do

                               (typically sends the event to some other view)

    for an undelegated message:

        sendEvent

            view has delegate

                ------> ask delegate via 'handlesKeyPress:key inView:view'

                <------ returns false

            view has controller

                ------> 'controller keyPress:key x:x y:y'

            view has no controller

                view has transformation

                    ----> 'view deviceKeyPress:key x:x y:y'

                          inverse transform x/y

                          ----> 'self keyPress:key x:xLogical y:yLogical'

                view has no transformation

                    ----> 'view keyPress:key x:x y:y'

    [author:]

        Claus Gittinger

    [see also:]

        WindowGroup WindowSensor

        DeviceWorkstation View

        KeyboardMap KeyboardForwarder EventListener

"

! !

!WindowEvent class methodsFor:'instance creation'!

damageFor:aView rectangle:aRectangle

    "create and return a new damage Event for aRectangle

     in aView"

    ^ (self new) for:aView type:#damage arguments:aRectangle

!

for:aView type:aSymbol

    "create and return a new windowEvent for sending

     aSymbol-message with no arguments to aView"

    ^ (self new) for:aView type:aSymbol arguments:#()

!

for:aView type:aSymbol arguments:argArray

    "create and return a new windowEvent for sending

     aSymbol-message with arguments to aView"

    ^ (self new) for:aView type:aSymbol arguments:argArray

! !

!WindowEvent class methodsFor:'event class access'!

buttonEvent

    ^ ButtonEvent

    "Created: 4.4.1997 / 13:45:04 / cg"

!

clientEvent

    ^ ClientEvent

    "Created: 4.4.1997 / 13:58:25 / cg"

!

keyboardEvent

    ^ KeyboardEvent

    "Created: 4.4.1997 / 13:41:44 / cg"

! !

!WindowEvent class methodsFor:'forwarding events'!

sendEvent:type arguments:arguments view:view

    "forward the event represented by type and arguments to the views delegate,

     the views controller or the view. 

     If there is a delegate, only messages which are understood by it are 

     forwarded. Also, the delegate is asked if it is willing to handle the event

     before.

     Delegated messages get the original view as an extra argument.

     Delegation has higher priority than controller forwarding."

    ^ self 

	sendEvent:type 

	arguments:arguments 

	view:view 

	withFocusOn:nil 

	delegate:true

!

sendEvent:type arguments:argArray view:view withFocusOn:focusView

    "forward the event represented by type and arguments to the views delegate,

     the views controller or the view. 

     If focusView is nonNil, and it is a keyboard event, it is forwarded to this

     view (even if there is a delegate).

     If there is a delegate, only messages which are understood by it are 

     forwarded. Also, the delegate is asked if it is willing to handle the event

     before.

     Delegated messages get the original view as an extra argument.

     Delegation has higher priority than both controller or focusView 

     forwarding."

    ^ self 

	sendEvent:type 

	arguments:argArray 

	view:view 

	withFocusOn:focusView 

	delegate:true 

!

sendEvent:type arguments:argArray view:view withFocusOn:focusView delegate:doDelegate

    "forward the event represented by type and arguments to the views delegate,

     the views controller or the view. 

     If focusView is nonNil, and it is a keyboard event, it is forwarded to this

     view (but not if there was a delegate in the first place).

     If doDelegate is true, keyboard and button events are forwarded to a

     delegate object (if non-nil). DoDelegate may be passed as true, to

     handle events which are already delegated.

     If there is a delegate, only messages which are understood by it are 

     forwarded. Also, the delegate is asked if it is willing to handle the event

     before.

     Delegated messages get the original view as an extra argument.

     Delegation has higher priority than both controller or focusView 

     forwarding."

    |delegate selector delegateMessage delegateQuery 

     eventReceiver controller deviceMessage

     isKeyEvent isButtonEvent isPointerEvent trans

     rect x y w h|

    isKeyEvent := isButtonEvent := isPointerEvent := false.

    type == #damage ifTrue:[

        view shown ifTrue:[

            rect := argArray.

            x := rect left.

            y := rect top.

            w := rect width.

            h := rect height.

            view transformation notNil ifTrue:[

                view deviceExposeX:x y:y width:w height:h

            ] ifFalse:[

                view exposeX:x y:y width:w height:h

            ]

        ].

        ^ self

    ].

    (type == #'keyPress:x:y:') ifTrue:[

        isKeyEvent := true.

        deviceMessage := #'deviceKeyPress:x:y:'.

        delegateMessage := #'keyPress:x:y:view:'.

        delegateQuery := #'handlesKeyPress:inView:'.

    ] ifFalse:[ (type == #'keyRelease:x:y:') ifTrue:[

        isKeyEvent := true.

        deviceMessage := #'deviceKeyRelease:x:y:'.

        delegateMessage := #'keyRelease:x:y:view:'.

        delegateQuery := #'handlesKeyRelease:inView:'.

    ] ifFalse:[ (type == #'buttonMotion:x:y:') ifTrue:[

        isButtonEvent := true.

        deviceMessage := #'deviceButtonMotion:x:y:'.

        delegateMessage := #'buttonMotion:x:y:view:'.

        delegateQuery := #'handlesButtonMotion:inView:'.

    ] ifFalse:[ (type == #'buttonPress:x:y:') ifTrue:[

        isButtonEvent := true.

        deviceMessage := #'deviceButtonPress:x:y:'.

        delegateMessage := #'buttonPress:x:y:view:'.

        delegateQuery := #'handlesButtonPress:inView:'.

    ] ifFalse:[ (type == #'buttonRelease:x:y:') ifTrue:[

        isButtonEvent := true.

        deviceMessage := #'deviceButtonRelease:x:y:'.

        delegateMessage := #'buttonRelease:x:y:view:'.

        delegateQuery := #'handlesButtonRelease:inView:'.

    ] ifFalse:[ (type == #'buttonShiftPress:x:y:') ifTrue:[

        isButtonEvent := true.

        deviceMessage := #'deviceButtonShiftPress:x:y:'.

        delegateMessage := #'buttonShiftPress:x:y:view:'.

        delegateQuery := #'handlesButtonShiftPress:inView:'.

    ] ifFalse:[ (type == #'buttonMultiPress:x:y:') ifTrue:[

        isButtonEvent := true.

        deviceMessage := #'deviceButtonMultiPress:x:y:'.

        delegateMessage := #'buttonMultiPress:x:y:view:'.

        delegateQuery := #'handlesButtonMultiPress:inView:'.

    ] ifFalse:[ (type == #'pointerEnter:x:y:') ifTrue:[

        isPointerEvent := true.

        deviceMessage := #'devicePointerEnter:x:y:'.

        delegateMessage := #'pointerEnter:x:y:view:'.

        delegateQuery := #'handlesPointerEnter:inView:'.

    ] ifFalse:[ (type == #'pointerLeave:') ifTrue:[

        isPointerEvent := true.

        deviceMessage := type.

        delegateMessage := #'pointerLeave:view:'.

        delegateQuery := #'handlesPointerLeave:inView:'.

    ] ifFalse:[ (type == #'exposeX:y:width:height:') ifTrue:[

        deviceMessage := #'deviceExposeX:y:width:height:'.

    ] ifFalse:[ (type == #'graphicsExposeX:y:width:height:final:') ifTrue:[

        deviceMessage := #'deviceGraphicsExposeX:y:width:height:final:'.

    ]]]]]]]]]]].

    "

     if there is a focusView, and its a keyboard event, pass it

     to that view (or its controller, or its delegate). 

     In this case, a coordinate which is outside of

     the focusView (0 @ 0) is passed as x/y coordinates.

    "

    (focusView notNil 

    and:[isKeyEvent]) ifTrue:[

        self sendEvent:type 

             arguments:(Array with:(argArray at:1) with:0 with:0)

             view:focusView 

             withFocusOn:nil

             delegate:doDelegate.

        ^ self

    ].

    doDelegate ifTrue:[

        "

         handle delegated messages

        "

        (isKeyEvent 

         or:[isButtonEvent 

         or:[isPointerEvent]]) ifTrue:[

            delegate := view delegate.

            "

             what a kludge - sending to delegate requires

             another selector and an additional argument ...

            "

            (delegate notNil

            and:[delegate respondsTo:delegateMessage]) ifTrue:[

                "

                 is the delegate interested in that event ?

                 (if it does not respond to the handlesXXX message,

                  we assume: NO)

                "

                ((delegate respondsTo:delegateQuery) 

                and:[delegate perform:delegateQuery with:(argArray at:1) with:view]) ifTrue:[

                    "

                     mhmh ... have to convert to logical coordinates

                    "        

                    (trans := view transformation) notNil ifTrue:[

                        argArray size > 2 ifTrue:[

                            argArray at:2 put:(trans applyInverseToX:(argArray at:2)).

                            argArray at:3 put:(trans applyInverseToY:(argArray at:3)).

                        ].

                    ].

                    argArray isNil ifTrue:[

                        delegate perform:delegateMessage with:view

                    ] ifFalse:[

                        delegate perform:delegateMessage withArguments:(argArray copyWith:view)

                    ].

                    ^ self

                ]

            ].

        ].

    ].

    (isKeyEvent 

     or:[isButtonEvent 

     or:[isPointerEvent]]) ifTrue:[

        view realized ifFalse:[

            ^ self

        ]

    ].

    "

     if there is a controller, that one gets all user events

    "

    eventReceiver := view.

    (controller := view controller) notNil ifTrue:[  

        (isKeyEvent 

         or:[isButtonEvent 

         or:[isPointerEvent

         or:[(type == #focusIn)

         or:[(type == #focusOut)]]]]) ifTrue:[

            eventReceiver := controller.

        ]

    ].

    "

     finally, another one:

     if the view has a transformation, edit the selector

     from #foo to #deviceFoo...

     This allows the view to handle the event either in device or

     logical coordinates. (since the deviceFoo-messages default implementation

     in DisplaySurface translates and resends).

     Actually, I could always send deviceXXX without speed penalty

     (event sending is no high frequency operation), but that just adds 

     another context to any debuggers walkback, making things less clear.

    "

    selector := type.

    view transformation notNil ifTrue:[

        (isKeyEvent

         or:[isButtonEvent

         or:[isPointerEvent

         or:[(type == #'exposeX:y:width:height:')

         or:[(type == #'graphicsExposeX:y:width:height:final:')]]]]) ifTrue:[

            selector := deviceMessage

        ]        

    ].

    eventReceiver perform:selector withArguments:argArray

    "Modified: 20.3.1997 / 14:25:31 / cg"

! !

!WindowEvent methodsFor:'accessing'!

arguments

    "return the arguments of the event"

    ^ arguments

!

arguments:anArray

    "set the arguments"

    arguments := anArray

!

key

    "return the key - nil is returned here.

     This is redefined in KeyboardEvent."

    ^ nil

    "Created: 1.8.1997 / 13:56:21 / cg"

!

rectangle

    "return the damage rectangle"

    ^ arguments "consider this a kludge"

!

type

    "return the type of the event"

    ^ type

!

view

    "return the view, for which the event is for"

    ^ view

!

view:aView

    "set the view, for which the event is for"

    view := aView

! !

!WindowEvent methodsFor:'printing & storing'!

displayString

    ^ self className 

      , '(' , type storeString 

      , ' view: ' , view className 

      , ' args: ' , arguments displayString

      , ')'