Something itches me from this discussion.

I somehow find myself with Glenn:
- should Bloc work with other than SDL/OSWindow?
- should SDL/OSWindow work with other than Bloc?

Merging the event hierarchy may prevent these two scenarios. And these scenarios are not only really possible: this is what the current scenario is. On one hand SDL and OSWindow work today with Morphic besides Block. On the other hand Bloc is, after all, an external library loaded on top of Pharo.

To explain better what I think:

- First I have the feeling that BIEvent and OSEvent are not the same thing. They have the same *NAME*. But they model different concepts. What is an event in bloc does not make sense in OSWindow and vice-versa. Why? because OSWindow does not manage widgets nor interactions between them.

- Second, I think that this idea of merging these hierarchies means merging layers also, what leads also to our monolithic system. I agree that this may impose some maintenance burden because there is the maintenance of the two layers plus their mapping (e.g., between the low-level events and the high-level events). But otherwise we are tampering the modularity.

Now, I liked more the suggestion of making Bloc using SDLEvents directly.

But then, wasn't it an idea behind OSWindow that users of OSWindow should be somehow abstracted from the backend behind. And SDL be just a backend? Something like Athens and Cairo.

Is SDL meant to work alone or be just a backend for OSWindow? Because if the case is the later, then maybe it makes sense to do the inverse: SDL should generate directly OSEvents and we should not have SDLEvent.

And going even further: Is OSWindow used in isolation? e.g., without morphic or bloc.

Because then, it the problem is the runtime overhead OSWindow should maybe not reify its events but propose a low level event handler mechanism where we could have

MorphicOSWindowEventHandler
�� >> keyEvent: ...
�� >> mouseEvent: ...

BlocOSWindowEventHandler
�� >> keyEvent: ...
�� >> mouseEvent: ...

And each framework generates its own events from low level SDL data. No event transformations, less duplications, and both Bloc and Morphic are plugged on top of OSWindow but not really strongly coupled to it.

-------- Original Message --------

Le 26/10/16 �� 20:40, Denis Kudriashov a ��crit��:

2016-10-26 19:45 GMT+02:00 Glenn Cavarl�� <glenn.cavarle@gmail.com>:

Yes, your are right.
What i mean is that it could be interesting if:
[ SDLEvent => BlEvent ]�� is substantially faster than�� [ SDLEvent =>
OSEvent => BlEvent ].
If the difference is not significant, i think that does not justify to not
benefit from OSWindow abstractions even if sometime they bring nothing more.

If you already thought about Announcements performance and produce optimized alternative then I think it is critical to get events fast.

Now we have 10 variables which are decoded from int by bit operations:

leftShift rightShift leftAlt rightAlt leftCtrl rightCtrl leftCmd rightCmd capsLock numLock

And then Bloc encodes them back to int. So for any event we have 20 operations and it is not just primitive calls.��
Also OSEvent creation produces own garbage for internal structures which also take time and memory.

But for me most important is how maintain both hierarchies. You answer Stef that nothing will change over events during years (nobody invent new one or not often).

But such argument could never be valid. Code is used, it could has bugs, it could be improved by itself. People will always need to work with this code, at least to read it. And it is difficult with two hierarchies which are managed by double dispatch. Try to follow how concrete BlEvent is produced.

And there is already some problem. I investigated deeply what happens in sdl about modifiers and buttons. It is not easy. But I see that some information becomes lost.

And Bloc also not provides full information from original objects (modifiers and buttons).��

So to fix these issues one needs to modify both hierarchies. First he needs to decide how decode modifiers from SDL and then how to encode them into Bloc bits.

And I am sure new issues will be found again and again. It is normal process.

So denis you suggest that Bloc uses directly SDLEvents.
This would make sense from your analysis.