Re: The Trunk: Morphic-mt.1182.mcz

Am 11.05.2018 08:17:05 schrieb H. Hirzel <[hidden email]>:

Hello Marcel,

could you please give some more background information about the
method #translateTo: which seems to have been introduced with this
change?

I loaded BabySRE-hjh.44 (http://wiki.squeak.org/squeak/2551)

into Squeak6.0alpha #17970 (current trunk) and got the error

AConnectorSRE (a morph) does not understand #translateTo:


--Hannes


...........................................................................................................................

translateTo: messages in current trunk:
............................................................................................................................


UserEvent>>translateTo: point

position := point.


DropEvent>>translateTo: point

position := point.


MorphicEvent>>translateTo: point
"empty method body"




On Mon, 20 Jun 2016 15:14:05.567 0000, [hidden email]
wrote:

> Marcel Taeumel uploaded a new version of Morphic to project The Trunk:
> http://source.squeak.org/trunk/Morphic-mt.1182.mcz
>
> ==================== Summary ====================
>
> Name: Morphic-mt.1182
> Author: mt
> Time: 20 June 2016, 5:13:55.570796 pm
> UUID: 825d8e52-1878-af49-9f7a-437b23e68d8c
> Ancestors: Morphic-mt.1181
>
> Moves implementation of focus event dispatching from various places into
> MorphicEventDispatcher. This will ensure consistency in the future because
> MorphicEventDispatcher encode the tree iteration with capturing and
> bubbling. Doing a focus event is just a shortcut into the tree. TextMorphs
> use that. Pop-up menus use that. Modal dialogs use that.
>
> Fixes missing coordinate transformations when capturing and bubbling for
> focus events.
>
> Simplify focus-related code in MenuMorph, UserDialogBoxMorph, and
> DockingBarMorph.
>
> At the time of writing, there seems to be no need anymore for Morph >>
> #handleFocusEvent:. Still, keep it for compatibility to other projects.
>
> =============== Diff against Morphic-mt.1181 ===============
>
> Item was removed:
> - ----- Method: DockingBarMorph>>handleFocusEvent: (in category
> 'events-processing') -----
> - handleFocusEvent: evt
> - "Handle focus events. Valid menu transitions are determined based on the
> menu currently holding the focus after the mouse went down on one of its
> children."
> -
> - | result filteredEvent |
> - (evt isMouse and:[ evt isMouseUp ]) ifTrue:[^ evt].
> -
> - result := self processEvent: evt.
> - filteredEvent := result == #rejected ifTrue: [evt] ifFalse: [result].
> -
> - "Need to handle keyboard input if we have the focus."
> - filteredEvent isKeyboard ifTrue: [^ super handleFocusEvent:
> filteredEvent].
> -
> - "We need to handle button clicks outside and transitions to local popUps
> so throw away everything else"
> - (filteredEvent isMouseOver or:[filteredEvent isMouse not])
> ifTrue:[^filteredEvent].
> - "What remains are mouse buttons and moves"
> - filteredEvent isMove ifFalse:[^super handleFocusEvent: filteredEvent].
> "handle clicks outside by regular means"
> - "Now it's getting tricky. On #mouseMove we might transfer control to
> *either* the currently active submenu or the pop up owner, if any. Since the
> active sub menu is always displayed upfront check it first."
> - selectedItem ifNotNil:[(selectedItem activateSubmenu: filteredEvent)
> ifTrue:[^filteredEvent]].
> - !
>
> Item was added:
> + ----- Method: DockingBarMorph>>mouseMove: (in category
> 'events-processing') -----
> + mouseMove: evt
> + "We might transfer control to *either* the currently active submenu or
> the pop up owner, if any. Since the active sub menu is always displayed
> upfront check it first."
> +
> + selectedItem ifNotNil:[selectedItem activateSubmenu: evt].!
>
> Item was added:
> + ----- Method: DockingBarMorph>>processFocusEvent:using: (in category
> 'events-processing') -----
> + processFocusEvent: evt using: dispatcher
> +
> + ^ dispatcher dispatchFocusEventFully: evt with: self!
>
> Item was added:
> + ----- Method: DockingBarMorph>>wantsEveryMouseMove (in category
> 'events-processing') -----
> + wantsEveryMouseMove
> + ^ true!
>
> Item was changed:
> ----- Method: HandMorph>>sendFocusEvent:to:clear: (in category 'private
> events') -----
> sendFocusEvent: anEvent to: focusHolder clear: aBlock
> "Send the event to the morph currently holding the focus"
> +
> | result w |
> w := focusHolder world ifNil:[aBlock value. ^ anEvent].
> w becomeActiveDuring:[
> ActiveHand := self.
> ActiveEvent := anEvent.
> + result := focusHolder processFocusEvent: anEvent.
> - result := focusHolder handleFocusEvent:
> - (anEvent transformedBy: (focusHolder transformedFrom: self)).
> ].
> + ^ result == #rejected ifTrue: [anEvent] ifFalse: [result "filtered
> event"]!
> - ^result == #rejected ifTrue: [anEvent] ifFalse: [result "filtered
> event"]!
>
> Item was removed:
> - ----- Method: MenuMorph>>handleFocusEvent: (in category 'events') -----
> - handleFocusEvent: evt
> - "Handle focus events. Valid menu transitions are determined based on the
> menu currently holding the focus after the mouse went down on one of its
> children."
> - | result filteredEvent |
> - result := self processEvent: evt.
> - filteredEvent := result == #rejected ifTrue: [evt] ifFalse: [result].
> -
> - "Need to handle keyboard input if we have the focus."
> - filteredEvent isKeyboard ifTrue: [^ super handleFocusEvent:
> filteredEvent].
> -
> - "We need to handle button clicks outside and transitions to local popUps
> so throw away everything else"
> - (filteredEvent isMouseOver or:[filteredEvent isMouse not])
> ifTrue:[^filteredEvent].
> - "What remains are mouse buttons and moves"
> - filteredEvent isMove ifFalse:[^super handleFocusEvent: filteredEvent].
> "handle clicks outside by regular means"
> - "Now it's getting tricky. On #mouseMove we might transfer control to
> *either* the currently active submenu or the pop up owner, if any. Since the
> active sub menu is always displayed upfront check it first."
> - selectedItem ifNotNil: [
> - (selectedItem activateSubmenu: filteredEvent)
> - ifTrue: [ ^filteredEvent ]
> - ifFalse: [
> - (self containsPoint: filteredEvent position) ifFalse: [
> - self selectItem: nil event: filteredEvent ] ] ].
> - "Note: The following does not traverse upwards but it's the best I can do
> for now"
> - popUpOwner ifNotNil:[(popUpOwner activateOwnerMenu: filteredEvent)
> ifTrue:[^filteredEvent]].
> - ^ filteredEvent!
>
> Item was removed:
> - ----- Method: MenuMorph>>handleMouseMove: (in category 'events') -----
> - handleMouseMove: evt
> - " If the mouse moves over an item not selected, we try to set it as
> selected.
> - If this happens depends on that the current selected item wants to
> release
> - its selection. "
> -
> - self selectedItem ifNil: [ ^super handleMouseMove: evt ].
> - (self selectedItem containsPoint: evt position) ifTrue: [ ^super
> handleMouseMove: evt ].
> - self
> - selectItem: (
> - self items
> - detect: [ :each | each containsPoint: evt position ]
> - ifNone: [ nil ])
> - event: evt.
> - super handleMouseMove: evt!
>
> Item was added:
> + ----- Method: MenuMorph>>mouseMove: (in category 'events') -----
> + mouseMove: evt
> + " If the mouse moves over an item not selected, we try to set it as
> selected.
> + If this happens depends on that the current selected item wants to
> release
> + its selection. "
> +
> + self selectedItem ifNil: [ ^ self ].
> + (self selectedItem containsPoint: evt position) ifTrue: [ ^ self ].
> + self
> + selectItem: (
> + self items
> + detect: [ :each | each containsPoint: evt position ]
> + ifNone: [ nil ])
> + event: evt.
> +
> + "Transfer control to *either* the currently active submenu or the pop up
> owner, if any. Since the active sub menu is always displayed upfront check
> it first."
> + selectedItem ifNotNil: [
> + (selectedItem activateSubmenu: evt)
> + ifTrue: [ ^self ]
> + ifFalse: [
> + (self containsPoint: evt position) ifFalse: [
> + self selectItem: nil event: evt ] ] ].
> +
> + "Note: The following does not traverse upwards but it's the best I can do
> for now"
> + popUpOwner ifNotNil:[popUpOwner activateOwnerMenu: evt]!
>
> Item was added:
> + ----- Method: MenuMorph>>processFocusEvent:using: (in category 'events')
> -----
> + processFocusEvent: evt using: dispatcher
> +
> + ^ dispatcher dispatchFocusEventFully: evt with: self!
>
> Item was added:
> + ----- Method: MenuMorph>>wantsEveryMouseMove (in category 'events') -----
> + wantsEveryMouseMove
> + ^ true!
>
> Item was changed:
> ----- Method: Morph>>handleFocusEvent: (in category 'events-processing')
> -----
> handleFocusEvent: anEvent
> + "Handle the given event. This message is sent if the receiver currently
> has the focus and is therefore receiving events directly from some hand.
> However, it might already have been handled due to overrides in
> #processFocusEvent:using:. We might want to get rid of this call-back in the
> future..."
> - "Handle the given event. This message is sent if the receiver currently
> has the focus and is therefore receiving events directly from some hand.
>
> + ^ anEvent wasHandled
> + ifTrue: [anEvent]
> + ifFalse: [self handleEvent: anEvent]!
> - 1) Event bubbling. Do event bubbling known from MorphicEventDispatcher by
> calling #handleEvent: also on all owners.
> - 2) Event capture filters. Walk along the owner chain in reverse order and
> apply capture filters as known from MorphicEventDispatcher.
> -
> - If you want to overwrite this in a subclass (for example to implement
> modal dialogs) ensure to call super instead if #handleEvent: directly."
> -
> - | filteredEvent |
> - filteredEvent := anEvent.
> -
> - "TODO: Add a check to ensure that our event dispatcher is actually of
> kind MorphicEventDispatcher?!! We do copy its behavior though... like self
> defaultEventDispatcher class == MorphicEventDispatcher? Or #isKindOf:?
> Anyway, the outermost morph determines the event dispatcher. See HandMorph
>>> #sendEvent:focus:clear: and PasteUpMorph >> #processEvent:."
> -
> - "Event capturing. Filters only because the capturing phase was bypassed
> by using the keyboard/mouse focus."
> - self withAllOwners reverseDo: [:morph | "reverse order to comply with
> default MorphEventDispatcher"
> - morph == anEvent hand ifFalse: [ "Fixes drag-and-drop bug."
> - filteredEvent := morph sendFilterEventCapture: filteredEvent for:
> morph.
> - filteredEvent wasIgnored ifTrue: [^ filteredEvent]]].
> -
> - "Event bubbling. Filters are processed in #handleEvent:."
> - self withAllOwnersDo: [:morph |
> - morph == anEvent hand ifFalse: [ "Fixes drag-and-drop bug."
> - filteredEvent := morph handleEvent: filteredEvent.
> - filteredEvent wasIgnored ifTrue: [^ filteredEvent]]].
> -
> - ^ filteredEvent!
>
> Item was added:
> + ----- Method: Morph>>processFocusEvent: (in category 'events-processing')
> -----
> + processFocusEvent: anEvent
> +
> + ^self processFocusEvent: anEvent using: self defaultEventDispatcher!
>
> Item was added:
> + ----- Method: Morph>>processFocusEvent:using: (in category
> 'events-processing') -----
> + processFocusEvent: anEvent using: defaultDispatcher
> + "Event dispatching shortcut."
> +
> + ^ defaultDispatcher dispatchFocusEvent: anEvent with: self!
>
> Item was changed:
> + ----- Method: MorphicEventDispatcher>>dispatchEvent:toSubmorphsOf: (in
> category 'support') -----
> - ----- Method: MorphicEventDispatcher>>dispatchEvent:toSubmorphsOf: (in
> category 'private') -----
> dispatchEvent: anEvent toSubmorphsOf: aMorph
> "Dispatch the given event to the submorphs of the given morph. For
> coordinate transformations, work only with copies. Either return the given
> event or a copy of any filtered event to employ immutability to some extent.
> --- PRIVATE!!"
>
> | localEvent filteredEvent |
> aMorph submorphsDo: [:child |
> localEvent := anEvent transformedBy: (child transformedFrom: aMorph).
> filteredEvent := child
> processEvent: localEvent
> using: self. "use same dispatcher"
> filteredEvent == #rejected ifFalse: [ "some event or #rejected symbol"
> self flag: #overlappingChildren. "mt: We cannot give two overlapping
> siblings the chance to handle the event!!"
> + ^ self nextFromOriginal: anEvent local: localEvent filtered:
> filteredEvent]].
> - filteredEvent == localEvent
> - ifTrue: [
> - localEvent wasHandled ifTrue: [anEvent copyHandlerState:
> localEvent].
> - anEvent wasIgnored: localEvent wasIgnored.
> - ^ anEvent]
> - ifFalse: [
> - filteredEvent := filteredEvent copy.
> - filteredEvent translateTo: anEvent position. "restore to
> untransformed coordinates"
> - filteredEvent wasHandled ifFalse: [filteredEvent copyHandlerState:
> anEvent]. "restore handler if needed"
> - ^ filteredEvent]]].
>
> ^ #rejected!
>
> Item was changed:
> + ----- Method: MorphicEventDispatcher>>dispatchEvent:withHandler:withMorph:
> (in category 'support') -----
> - ----- Method: MorphicEventDispatcher>>dispatchEvent:withHandler:withMorph:
> (in category 'private') -----
> dispatchEvent: anEvent withHandler: aHandler withMorph: aMorph
> "Perform the actual event dispatch. Use the given object as handler. Ask
> submorphs first to handle the event. Then bubble up. Stop if ignored. Note
> that event rejection and event filters are two separete concepts. Filters
> come from the outside. Rejection is a morph's decision.
>
> * The top-most chain of visible, unlocked morphs containing the event
> position will get a chance to handle the event.
> * When travelling up, the prospective handler is always executed. The
> handler needs to check if the event was handled before as well as checking
> if somebody else's handler has been installed.
> * If another handler has been installed but the event was not handled it
> means that somebody up in the hierarchy wants to handle the event."
>
> | result filteredEvent |
>
> result := self dispatchEvent: anEvent toSubmorphsOf: aMorph.
>
> result == #rejected "Anybody?"
> ifFalse: [filteredEvent := result]
> ifTrue: [
> "My submorphs did not want it. Do I want it anyway? It's about locked
> children..."
> (aMorph containsPoint: anEvent position event: anEvent)
> ifFalse: [^ #rejected].
> filteredEvent := anEvent "there was no filtering, only basic
> rejects"].
>
> "Receiver is in the top-most unlocked, visible chain."
> (aHandler notNil and: [filteredEvent wasIgnored not])
> ifTrue: [filteredEvent := aHandler handleEvent: filteredEvent].
>
> ^ filteredEvent!
>
> Item was added:
> + ----- Method: MorphicEventDispatcher>>dispatchFocusEvent:with: (in
> category 'focus events') -----
> + dispatchFocusEvent: anEventWithGlobalPosition with: focusMorph
> + "Dispatch the given event to the given morph. Simulate capturing phase,
> handle the event, then do bubbling."
> +
> + | currentEvent |
> + "1) Capturing phase."
> + currentEvent := self doCapturingForFocusEvent: anEventWithGlobalPosition
> with: focusMorph.
> + currentEvent == #rejected ifTrue: [^ #rejected].
> + currentEvent wasIgnored ifTrue: [^ currentEvent].
> +
> + "2) No sub-tree processing here. Use #dispatchFocusEventFully:with: if
> you want that, too."
> +
> + "3) Let the focus morph handle the event."
> + currentEvent := self doHandlingForFocusEvent: currentEvent with:
> focusMorph.
> + currentEvent wasIgnored ifTrue: [^ currentEvent].
> +
> + "4) Bubbling phase"
> + ^ self doBubblingForFocusEvent: currentEvent with: focusMorph!
>
> Item was added:
> + ----- Method: MorphicEventDispatcher>>dispatchFocusEventFully:with: (in
> category 'focus events') -----
> + dispatchFocusEventFully: anEventWithGlobalPosition with: focusMorph
> + "Dispatch the given event to the given morph. Do capturing, processing in
> sub-tree, and bubbling."
> +
> + | currentEvent |
> + "1) Capturing phase."
> + currentEvent := self doCapturingForFocusEvent: anEventWithGlobalPosition
> with: focusMorph.
> + currentEvent == #rejected ifTrue: [^ #rejected].
> + currentEvent wasIgnored ifTrue: [^ currentEvent].
> +
> + "2) Sub-tree processing."
> + currentEvent := self doProcessingForFocusEvent: currentEvent with:
> focusMorph.
> + currentEvent wasIgnored ifTrue: [^ currentEvent].
> +
> + "3) Let the focus morph handle the event. Usually no effect because
> previous sub-tree processing involved the focus morph already -- at least in
> the bubbling phase. Skip it?"
> + currentEvent := self doHandlingForFocusEvent: currentEvent with:
> focusMorph.
> + currentEvent wasIgnored ifTrue: [^ currentEvent].
> +
> + "4) Bubbling phase."
> + ^ self doBubblingForFocusEvent: currentEvent with: focusMorph!
>
> Item was added:
> + ----- Method: MorphicEventDispatcher>>doBubblingForFocusEvent:with: (in
> category 'support') -----
> + doBubblingForFocusEvent: anEvent with: focusMorph
> + "Simulate real event bubbling up to the focused morph's outermost owner.
> Applies event bubble filters via Morph >> #handleEvent:. Watch out for
> coordinate transformations and some globals (ActiveWorld, ...)."
> +
> + | currentEvent filteredEvent localEvent referenceMorph |
> + currentEvent := anEvent.
> + referenceMorph := anEvent hand.
> +
> + focusMorph allOwnersDo: [:ownerMorph |
> + ownerMorph == anEvent hand ifFalse: [ "Never bubble up to the hand morph
> but only up to the world."
> + localEvent := currentEvent transformedBy: (ownerMorph transformedFrom:
> referenceMorph).
> + filteredEvent := ownerMorph handleEvent: localEvent.
> + currentEvent := self nextFromOriginal: currentEvent local: localEvent
> filtered: filteredEvent.
> + currentEvent wasIgnored ifTrue: [^ currentEvent]]].
> +
> + ^ currentEvent!
>
> Item was added:
> + ----- Method: MorphicEventDispatcher>>doCapturingForFocusEvent:with: (in
> category 'support') -----
> + doCapturingForFocusEvent: anEvent with: focusMorph
> + "Simulate real event capturing down to the focused morph. Apply event
> capture filters. Watch out for coordinate transformations. Keep the
> filter-ignore-reject order like in Morph >> #processEvent:using:."
> +
> + | currentEvent filteredEvent localEvent referenceMorph |
> + currentEvent := anEvent.
> + referenceMorph := anEvent hand.
> +
> + "Event capturing. Filters only because the capturing phase was bypassed
> by using the keyboard/mouse focus."
> + focusMorph withAllOwners reverseDo: [:ownerMorph | "reverse order to
> comply with regular dispatching"
> + ownerMorph == anEvent hand ifFalse: [ "Never dispatch the hand morph. It
> already did so."
> + localEvent := currentEvent transformedBy: (ownerMorph transformedFrom:
> referenceMorph).
> +
> + filteredEvent := ownerMorph sendFilterEventCapture: localEvent for:
> ownerMorph.
> +
> + "Ignoring has higher priority but the reject-check must be with local
> event coodinates."
> + (filteredEvent wasIgnored not and: [ownerMorph rejectsEvent:
> filteredEvent])
> + ifTrue: [^ #rejected].
> +
> + currentEvent := self nextFromOriginal: currentEvent local: localEvent
> filtered: filteredEvent.
> + currentEvent wasIgnored ifTrue: [^ currentEvent]]].
> +
> + ^ currentEvent!
>
> Item was added:
> + ----- Method: MorphicEventDispatcher>>doHandlingForFocusEvent:with: (in
> category 'support') -----
> + doHandlingForFocusEvent: currentEvent with: focusMorph
> +
> + | localEvent filteredEvent |
> + localEvent := currentEvent transformedBy: (focusMorph transformedFrom:
> currentEvent hand).
> + filteredEvent := focusMorph handleFocusEvent: localEvent.
> + ^ self nextFromOriginal: currentEvent local: localEvent filtered:
> filteredEvent.!
>
> Item was added:
> + ----- Method: MorphicEventDispatcher>>doProcessingForFocusEvent:with: (in
> category 'support') -----
> + doProcessingForFocusEvent: currentEvent with: focusMorph
> + "Sub-tree processing (including capturing from focus morph down to
> something and bubbling up back to focus morph). Never reject in the end."
> +
> + | localEvent filteredEvent |
> + localEvent := currentEvent transformedBy: (focusMorph transformedFrom:
> currentEvent hand).
> + filteredEvent := focusMorph processEvent: localEvent using: self.
> + ^ filteredEvent == #rejected
> + ifTrue: [currentEvent] "Can happen if you click, e.g., outside the
> bounds of the focus morph"
> + ifFalse: [self nextFromOriginal: currentEvent local: localEvent
> filtered: filteredEvent]!
>
> Item was added:
> + ----- Method: MorphicEventDispatcher>>nextFromOriginal:local:filtered: (in
> category 'support') -----
> + nextFromOriginal: originalEvent local: localEvent filtered: filteredEvent
> + "Take the filtered event if different but always keep the original
> coordinates."
> +
> + filteredEvent == localEvent
> + ifTrue: [ "Use original event but keep track of ignored flag."
> + localEvent wasHandled ifTrue: [originalEvent copyHandlerState:
> localEvent].
> + originalEvent wasIgnored: localEvent wasIgnored.
> + ^ originalEvent]
> + ifFalse: [ "There was an event transformation. Copy, revert coordinates,
> keep handler state."
> + | result |
> + result := filteredEvent copy. "Never mutate position without copying.
> MouseClickState etc. will break otherwise."
> + result translateTo: originalEvent position. "restore to untransformed
> coordinates"
> + result wasHandled ifFalse: [result copyHandlerState: originalEvent].
> + ^ result].
> + !
>
> Item was removed:
> - ----- Method: UserDialogBoxMorph>>handleFocusEvent: (in category
> 'constructing') -----
> - handleFocusEvent: evt
> - "Handle focus events. Valid menu transitions are determined based on the
> menu currently holding the focus after the mouse went down on one of its
> children. Need to handle keyboard input if we have the focus."
> -
> - | result filteredEvent |
> - result := self processEvent: evt.
> - filteredEvent := result == #rejected ifTrue: [evt] ifFalse: [result].
> -
> - ^ super handleFocusEvent: filteredEvent!
>
> Item was added:
> + ----- Method: UserDialogBoxMorph>>processFocusEvent:using: (in category
> 'events') -----
> + processFocusEvent: evt using: dispatcher
> +
> + ^ dispatcher dispatchFocusEventFully: evt with: self!
>
>
>