Support for global Events

[ghost]

It would be great if there was support for globally broadcasting Events.
Also it would be great if the @work annotation had an option to broadcast its events.

An example use case would be setting up a global loading indicator:

import asyncio

from textual import work
from textual.app import App
from textual.screen import Screen
from textual.worker import Worker, WorkerState


class DummyScreen(Screen):
    def on_mount(self):
        self.dummy()

    @work
    async def dummy(self):
        await asyncio.sleep(5)


class TestApp(App):
    def on_mount(self):
        self.push_screen(DummyScreen())

    async def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
        """Show Loading Indicator while work is in progress."""
        num_active = 0
        for worker in self.workers:
            if worker.state in (WorkerState.PENDING, WorkerState.RUNNING):
                num_active += 1

        if num_active > 0:
            self.log("################ enable loading indicator")
        else:
            self.log("|||||||||||||||| disable loading indicator")


app = TestApp()

if __name__ == "__main__":
    app.run()

This code currently doesn't run on_worker_state_changed inside the TestApp. It would need to be moved to DummyScreen and duplicated for every Screen, which wouldn't make sense.

[willmcgugan]

I'm not clear on what "broadcasting" would do. Sending events to every widget would almost certainly be too expensive.

[ghost]

I see... how about sending it to every Screen and ModalScreen then?
Right now you always need to store a reference of Screens I want to send messages to, which doesn't look very clean and leads to code like self.app.SCREENS["log"].post_message(..)

[raayu83]

In the end what I wanted to achieve with this is to have a way to send messages to Screens of certain classes or IDs.
E.g. I have a main screen that has a widget to log actions that have been made.
Right now I have to store a direct reference to the main sceen as shown above, which does not seem very clean to me.

What kind of alternate solutions are available to that?

If there is none, how about adding some kind of new way to send messages in a way similar to the query_one method?
E.g. something like: def post_message_global(self, message:, selector, expect_type=None):

[willmcgugan]

You can get a screen with App.get_Screen.

But I am unclear on what problem your post_message_global is attempting to solve. Storing a reference to the screen you want to work with seems like a reasonable solution.

[raayu83]

Ah so there was a get_screen method that accepts a class as the input... with that the solution I suggest isn't necessary anymore.