search

pharo-graphics / Toplo

A widget framework on top of Bloc
MIT License
17 stars 8 forks source link

Error: #focusOwner was sent to nil #89

Open labordep opened 5 months ago

labordep commented 5 months ago

Bug when I'm using my application and resizing the window a lot of time. The list element is inside TabPane, I'm switching between tabs and the bug appears after to open/close/reopen tabs.

image

Important: my image have this patch (not include in Toplo commit):

ToLabel>>initialize

    self class initializeSlots: self.
    super initialize.
    self applySkinInstallerOnFirstRequest: false. "PATCH HERE"

    self layout: self defaultLayout.
    self fitContent.

    self lineMode: self defaultLineMode.
    self innerElement: self defaultTextElement. 
    self text: self defaultText.

    self isEditable: false.
    self addEventHandler: self defaultEventHandler

The stack:

UndefinedObject(Object)>>doesNotUnderstand: #focusOwner
UndefinedObject>>doesNotUnderstand: #focusOwner
ToListPrimarySelectionElement(BlElement)>>attachSpace
[ :anElement |

        anElement isAttachedToSceneGraph
            ifFalse: [ anElement attachSpace ].

        anElement dispatchAddedToSceneGraph ] in ToListElement(BlElement)>>dispatchAddedToSceneGraph in Block: [ :anElement |...
Array(SequenceableCollection)>>do:
BlChildrenArray>>do:
ToListElement(BlElement)>>childrenDo:
ToListElement(BlElement)>>dispatchAddedToSceneGraph
[ :anElement |

        anElement isAttachedToSceneGraph
            ifFalse: [ anElement attachSpace ].

        anElement dispatchAddedToSceneGraph ] in MyAppPanel(BlElement)>>dispatchAddedToSceneGraph in Block: [ :anElement |...
Array(SequenceableCollection)>>do:
BlChildrenArray>>do:
MyAppPanel(BlElement)>>childrenDo:
MyAppPanel(BlElement)>>dispatchAddedToSceneGraph
[ :anElement |

        anElement isAttachedToSceneGraph
            ifFalse: [ anElement attachSpace ].

        anElement dispatchAddedToSceneGraph ] in ToPane(BlElement)>>dispatchAddedToSceneGraph in Block: [ :anElement |...
Array(SequenceableCollection)>>do:
BlChildrenArray>>do:
ToPane(BlElement)>>childrenDo:
ToPane(BlElement)>>dispatchAddedToSceneGraph
[ :anElement |

        anElement isAttachedToSceneGraph
            ifFalse: [ anElement attachSpace ].

        anElement dispatchAddedToSceneGraph ] in ToPane(BlElement)>>dispatchAddedToSceneGraph in Block: [ :anElement |...
Array(SequenceableCollection)>>do:
BlChildrenArray>>do:
ToPane(BlElement)>>childrenDo:
ToPane(BlElement)>>dispatchAddedToSceneGraph
[ :anElement |

        anElement isAttachedToSceneGraph
            ifFalse: [ anElement attachSpace ].

        anElement dispatchAddedToSceneGraph ] in ToTabPane(BlElement)>>dispatchAddedToSceneGraph in Block: [ :anElement |...
Array(SequenceableCollection)>>do:
BlChildrenArray>>do:
ToTabPane(BlElement)>>childrenDo:
ToTabPane(BlElement)>>dispatchAddedToSceneGraph
[ :anElement |

        anElement isAttachedToSceneGraph
            ifFalse: [ anElement attachSpace ].

        anElement dispatchAddedToSceneGraph ] in BlElement>>dispatchAddedToSceneGraph in Block: [ :anElement |...
Array(SequenceableCollection)>>do:
BlChildrenArray>>do:
BlElement>>childrenDo:
BlElement>>dispatchAddedToSceneGraph
[ :anElement |

        anElement isAttachedToSceneGraph
            ifFalse: [ anElement attachSpace ].

        anElement dispatchAddedToSceneGraph ] in MyAppPanel2(BlElement)>>dispatchAddedToSceneGraph in Block: [ :anElement |...
Array(SequenceableCollection)>>do:
BlChildrenArray>>do:
MyAppPanel2(BlElement)>>childrenDo:
MyAppPanel2(BlElement)>>dispatchAddedToSceneGraph
[ :anElement |

        anElement isAttachedToSceneGraph
            ifFalse: [ anElement attachSpace ].

        anElement dispatchAddedToSceneGraph ] in ToPane(BlElement)>>dispatchAddedToSceneGraph in Block: [ :anElement |...
Array(SequenceableCollection)>>do:
BlChildrenArray>>do:
ToPane(BlElement)>>childrenDo:
ToPane(BlElement)>>dispatchAddedToSceneGraph
ToPane(BlElement)>>dispatchChildAdded:
ToPane(BlElement)>>addChild:at:
ToPane(BlElement)>>addChild:
ToTab>>onSelected
ToTab>>checkableCheckEvent:
[ :event | self checkableCheckEvent: event ] in ToTab>>onAddedToParent in Block: [ :event | self checkableCheckEvent: event ]
FullBlockClosure(BlockClosure)>>cull:
BlEventHandler>>handleEvent:
BlHandlerAnnouncementSubscription>>deliver:
[ subscription deliver: anAnnouncement ] in SubscriptionRegistry>>deliver:to:startingAt: in Block: [ subscription deliver: anAnnouncement ]
FullBlockClosure(BlockClosure)>>ifCurtailed:
SubscriptionRegistry>>deliver:to:startingAt:
SubscriptionRegistry>>deliver:to:
SubscriptionRegistry>>deliver:
Announcer>>announce:
BlHandlerAnnouncerRegistry>>dispatchEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchArrivedEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchEvent:next:
BlElementEventDispatcher(BlEventDispatcher)>>dispatchEvent:
ToTab(BlElement)>>dispatchEvent:
ToTab>>privateChecked:
ToTab>>checked:
ToTab>>switchToNextCheckStateOnClick
ToSkinStateGenerator>>primaryClickEvent:
[ self primaryClickEvent: anEvent ] in ToSkinStateGenerator>>clickEvent: in Block: [ self primaryClickEvent: anEvent ]
BlMousePrimaryButton>>ifPrimary:secondary:middle:other:
BlPrimaryClickEvent(BlMouseEvent)>>ifPrimary:secondary:middle:other:
ToSkinStateGenerator>>clickEvent:
BlPrimaryClickEvent(BlClickEvent)>>sendTo:
ToSkinStateGenerator>>handleEvent:
BlHandlerAnnouncementSubscription>>deliver:
[ subscription deliver: anAnnouncement ] in SubscriptionRegistry>>deliver:to:startingAt: in Block: [ subscription deliver: anAnnouncement ]
FullBlockClosure(BlockClosure)>>ifCurtailed:
SubscriptionRegistry>>deliver:to:startingAt:
SubscriptionRegistry>>deliver:to:
SubscriptionRegistry>>deliver:
Announcer>>announce:
BlHandlerAnnouncerRegistry>>dispatchEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchBubblingEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchEvent:next:
BlEventDispatcherChain>>dispatchEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchEvent:next:
BlEventDispatcherChain>>dispatchEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchEvent:next:
BlEventDispatcherChain>>dispatchEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchEvent:next:
BlEventDispatcherChain>>dispatchEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchEvent:next:
BlEventDispatcherChain>>dispatchEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchEvent:next:
BlEventDispatcherChain>>dispatchEvent:
BlElementEventDispatcher(BlBubblingEventDispatcher)>>dispatchEvent:next:
BlEventDispatcherChain>>dispatchEvent:
BlEvent class>>fireEvent:target:
BlEvent class>>fireEvent:
BlMouseProcessor(BlBaseEventProcessor)>>fireEvent:
BlMouseProcessor>>fireEvent:
BlMouseProcessor>>fireClickEventFrom:
BlMouseProcessor>>processMouseUp:
BlMouseProcessor>>handleMouseUp:
BlSpaceEventListener>>mouseUpEvent:
BlPrimaryMouseUpEvent(BlMouseUpEvent)>>sendTo:
BlSpaceEventListener(BlEventListener)>>handleEvent:
BlHandlerAnnouncementSubscription>>deliver:
[ subscription deliver: anAnnouncement ] in SubscriptionRegistry>>deliver:to:startingAt: in Block: [ subscription deliver: anAnnouncement ]
FullBlockClosure(BlockClosure)>>ifCurtailed:
SubscriptionRegistry>>deliver:to:startingAt:
SubscriptionRegistry>>deliver:to:
SubscriptionRegistry>>deliver:
Announcer>>announce:
BlHandlerAnnouncerRegistry>>dispatchEvent:
BlDirectEventDispatcher>>dispatchEvent:next:
BlDirectEventDispatcher(BlEventDispatcher)>>dispatchEvent:
[
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] in [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ] in [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] in [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ] in [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ] in [ :theSpace |
            "We must update focused element before processing events, otherwise keyboard events,
            for example, will be handled by the wrong element"
            aSpace doUpdateFocus.

            theSpace hostSpaceDo: [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ].
            theSpace mouseProcessor generateEvents ] in BlSpaceFrameEventPhase>>runOn: in Block: [...
FullBlockClosure(BlockClosure)>>cull:
BlSpace>>hostSpaceDo:ifAbsent:
BlSpace>>hostSpaceDo:
[
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ] in [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] in [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ] in [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ] in [ :theSpace |
            "We must update focused element before processing events, otherwise keyboard events,
            for example, will be handled by the wrong element"
            aSpace doUpdateFocus.

            theSpace hostSpaceDo: [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ].
            theSpace mouseProcessor generateEvents ] in BlSpaceFrameEventPhase>>runOn: in Block: [...
FullBlockClosure(BlockClosure)>>ensure:
BlNullTelemetry(BlTelemetry)>>timeSync:during:
[ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] in [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ] in [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ] in [ :theSpace |
            "We must update focused element before processing events, otherwise keyboard events,
            for example, will be handled by the wrong element"
            aSpace doUpdateFocus.

            theSpace hostSpaceDo: [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ].
            theSpace mouseProcessor generateEvents ] in BlSpaceFrameEventPhase>>runOn: in Block: [ :anEvent |...
LinkedList>>do:
BlHostEventFetcher>>fetchedEventsDo:
BlOSWindowSDL2HostSpace(BlOSWindowHostSpace)>>fetchedEventsDo:
[ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ] in [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ] in [ :theSpace |
            "We must update focused element before processing events, otherwise keyboard events,
            for example, will be handled by the wrong element"
            aSpace doUpdateFocus.

            theSpace hostSpaceDo: [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ].
            theSpace mouseProcessor generateEvents ] in BlSpaceFrameEventPhase>>runOn: in Block: [ :aHostSpace |...
FullBlockClosure(BlockClosure)>>cull:
BlSpace>>hostSpaceDo:ifAbsent:
BlSpace>>hostSpaceDo:
[ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ] in [ :theSpace |
            "We must update focused element before processing events, otherwise keyboard events,
            for example, will be handled by the wrong element"
            aSpace doUpdateFocus.

            theSpace hostSpaceDo: [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ].
            theSpace mouseProcessor generateEvents ] in BlSpaceFrameEventPhase>>runOn: in Block: [ ...
FullBlockClosure(BlockClosure)>>cull:
BlSpace>>hostSpaceDo:ifAbsent:
BlSpace>>hostSpaceDo:
[ :theSpace |
            "We must update focused element before processing events, otherwise keyboard events,
            for example, will be handled by the wrong element"
            aSpace doUpdateFocus.

            theSpace hostSpaceDo: [ 
                "Process events enqueued by host space and dispatch them to the scene graph"

                theSpace eventRecorder onPulse.

                theSpace hostSpaceDo: [ :aHostSpace |
                    aHostSpace fetchedEventsDo: [ :anEvent |
                    "we have to test for existance of the host space before handling each event because
                    it is possible that a space is closed due to an event"

                    theSpace telemetry
                        timeSync: [ 'Process event {1}' format: { anEvent } ]
                        during: [
                            theSpace hostSpaceDo: [
                                theSpace eventRecorder record: anEvent.
                                theSpace eventDispatcher dispatchEvent: anEvent ] ]  ] ].

                theSpace hostSpaceDo: [ :aHostSpace | aHostSpace generateEvents ] ].
            theSpace mouseProcessor generateEvents ] in BlSpaceFrameEventPhase>>runOn: in Block: [ :theSpace |...
FullBlockClosure(BlockClosure)>>cull:
BlSpace>>dispatchTimeEvent:during:
BlSpaceFrameEventPhase>>runOn:
BlSpaceFrame>>runCurrentPhaseOn:
BlSpaceFrame>>runOn:
BlSpace>>processPulse
BlSpace>>pulse
[ :eachSpace | eachSpace pulse ] in [
        self tryToRunDeferredActions.
        spaceManager do: [ :eachSpace | eachSpace pulse ]
    ] in BlParallelUniverse>>pulseSynchronously in Block: [ :eachSpace | eachSpace pulse ]
Array(SequenceableCollection)>>do:
BlSpaceManager>>do:
[
        self tryToRunDeferredActions.
        spaceManager do: [ :eachSpace | eachSpace pulse ]
    ] in BlParallelUniverse>>pulseSynchronously in Block: [...
FullBlockClosure(BlockClosure)>>ensure:
BlParallelUniverse>>pulseSynchronously
[ self pulseSynchronously ] in BlParallelUniverse>>pulse in Block: [ self pulseSynchronously ]
FullBlockClosure(BlockClosure)>>ensure:
BlParallelUniverse>>pulse
[
            pulseStartMS := Time millisecondClockValue.

            (BlParallelUniverse forHost: hostClass) pulse.

            pulseDurationMS := Time millisecondClockValue - pulseStartMS.

            self waitUntilNextPulse 

        ] in [ [
            pulseStartMS := Time millisecondClockValue.

            (BlParallelUniverse forHost: hostClass) pulse.

            pulseDurationMS := Time millisecondClockValue - pulseStartMS.

            self waitUntilNextPulse 

        ] doWhileTrue: [ loopProcess == Processor activeProcess ] ] in BlHostPulseLoop>>newLoopBlock in Block: [...
FullBlockClosure(BlockClosure)>>doWhileTrue:
[ [
            pulseStartMS := Time millisecondClockValue.

            (BlParallelUniverse forHost: hostClass) pulse.

            pulseDurationMS := Time millisecondClockValue - pulseStartMS.

            self waitUntilNextPulse 

        ] doWhileTrue: [ loopProcess == Processor activeProcess ] ] in BlHostPulseLoop>>newLoopBlock in Block: [ [...
[self value.
            "IMPORTANT: Do not step over next line of code. See method comments for details"
            Processor terminateRealActive] in FullBlockClosure(BlockClosure)>>newProcess in Block: [self value....

My config:

labordep commented 5 months ago

Same problem when I'm trying to edit my application view in Pyramid (F12 shortcut):

image

labordep commented 5 months ago

Same problem on latest Toplo/Bloc commit of today

LouisePla commented 5 months ago

Same error when I play with the selection on the lists below :

|tabsPanel list1 list2 tab1 tab2|

list1 := ToListElement new. list1 constraints vertical matchParent. list1 constraints horizontal matchParent. 1 to: 10 do: [ :i | list1 data add: 'Hello ' , i asString ].

list2 := ToListElement new. list2 constraints vertical matchParent. list2 constraints horizontal matchParent. 11 to: 20 do: [ :i | list1 data add: 'Goodbye ' , i asString ].

tabsPanel := ToTabPane new.

tab1 := ToTab new. tab1 labelText: 'Hello'. tab1 paneBuilder: [ :pane :theTabPane | pane addChild: list1 ].

tab2 := ToTab new. tab2 labelText: 'Goodbye'. tab2 paneBuilder: [ :pane :theTabPane | pane addChild: list2 ].

tabsPanel add: tab1. tabsPanel add: tab2. tabsPanel openInSpace