Informing other screen that something happened on current screen

[jakubziebin]

So i have a similar structure:

from textual import on
from textual.app import App, ComposeResult
from textual.binding import Binding
from textual.message import Message
from textual.screen import Screen
from textual.widgets import Footer, Label


class Raw(Screen):
    class Changed(Message):
        pass

    def on_mount(self):
        self.post_message(self.Changed())

    def compose(self) -> ComposeResult:
        yield Label("Raw screen")
        yield Footer()


class ExampleElement(Label):
    @on(Raw.Changed)
    def log_changed(self):
        self.log(f"{self} received a message!")


class Example(Screen):
    BINDINGS = [
        Binding("f2", "push_raw", "Push raw"),
    ]

    def compose(self) -> ComposeResult:
        yield Label("Example screen")
        yield ExampleElement("Example")
        yield Footer()

    def action_push_raw(self):
        self.app.push_screen(Raw())

    @on(Raw.Changed)
    def log_changed(self):
        self.log(f"{self} received a message!")


class MyApp(App[None]):
    BINDINGS = [
        Binding("f3", "pop_screen", "Pop screen")
    ]

    @on(Raw.Changed)
    def log_changed(self):
        self.log(f"{self} received a message!")

    def on_mount(self):
        self.push_screen(Example())

MyApp().run()

On one of the widgets that is placed on the Example screen I want to capture a Message from Raw, is there an elegant way to do this?

[davep]

It's not really very clear to me, from the above, what it is you'r trying to do. Do you think you could perhaps reduce the example a little, and/or walk through the exact steps someone should follow with the example code, and say what you would be hoping to see, and how things differ?

Also, as some background, perhaps you could more generally say what it is you want to achieve, it might be there's a better way than using messages, for example.

[jakubziebin]

Ok, so I've shortened my example and hopefully it will be clearer.

from textual import on
from textual.app import App, ComposeResult
from textual.binding import Binding
from textual.message import Message
from textual.screen import Screen
from textual.widgets import Footer, Label, Button


class Sender(Screen):
    class Changed(Message):
        """Message that should receive screen Receiver"""
        pass

    def on_mount(self):
        self.post_message(self.Changed())

    def compose(self) -> ComposeResult:
        yield Label("Sender screen")
        yield Footer()


class Receiver(Screen):
    BINDINGS = [
        Binding("f2", "push_sender", "Push sender"),
    ]

    def __init__(self):
        super().__init__()
        self.__button = Button()

    def compose(self) -> ComposeResult:
        yield Label("Receiver screen")
        yield self.__button
        yield Footer()

    def action_push_sender(self):
        self.app.push_screen(Sender())

    @on(Sender.Changed)
    def log_changed(self):
        self.log(f"{self} received a message!")
        self.__button.disabled = True


class MyApp(App[None]):
    BINDINGS = [
        Binding("f3", "pop_screen", "Pop screen")
    ]

    def on_mount(self):
        self.push_screen(Receiver())

MyApp().run()

Generally my goal is to set Button.disabled to True on the Receiver screen if certain conditions are met. So the way is as follows -> User enters the Sender screen -> user performs some action, after the action the user sends back to the Receiver -> When the user on the Sender screen performs one action the Sender sends a message to the Receiver that it needs to change Button.disabled to True

[davep]

I see, thanks. The main problem you have here is that messages don't bubble up the screen stack; they only bubble up the DOM, and the DOM is always whatever is within the active screen. So in your case the message will go Sender -> App.

Based on what you've said you want to do here, I think you probably would be better off reviewing the guide to screens in Textual, and especially the section on passing data back from a screen. For example, the following code seems to implement what you're saying here:

from textual import on
from textual.app import App, ComposeResult
from textual.screen import Screen
from textual.widgets import Button


class Child(Screen[bool]):

    def compose(self) -> ComposeResult:
        yield Button("Enable", id="enable")
        yield Button("Disable", id="disable")

    @on(Button.Pressed)
    def decide(self, event: Button.Pressed) -> None:
        self.dismiss(event.control.id == "enable")


class Main(Screen):

    def compose(self) -> ComposeResult:
        yield Button("This will enable/disable", id="tester")
        yield Button("Show child screen", id="show-child")

    def enable_disable(self, enable: bool) -> None:
        self.query_one("#tester").disabled = not enable

    @on(Button.Pressed, "#show-child")
    def show_child(self) -> None:
        self.app.push_screen(Child(), callback=self.enable_disable)


class PassingScreenDataApp(App[None]):

    def on_mount(self) -> None:
        self.push_screen(Main())

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

[jakubziebin]

I am not sure about this solution. I have a certain inheritance structure for the screens in the application and I would generally have to rebuild the whole design concept. The second reason is that I forgot something that could be checked every time I activate a screen. But I would have to query all the widgets that need to be checked and call the method that belongs to them, is this possible?

[davep]

Again, it's not very clear to me what the question is, or why your application design would mean this method of passing data back to the parent screen wouldn't work.

Perhaps a clear explanation of your design, and the decisions behind it, would make it easier for someone to suggest a better approach?

Simply put though: posting a message on a screen won't fire event handlers on a screen that happened to push it, not unless you provide access to a reference to that screen and then post a message to it.