How to have a widget focusable only when it's scrollbars are active?

[mzebrak]

Hi. I need to have a container that should be focusable only when it has any of its scrollbars horizontal/vertical shown (it's mostly related to keyboard support - you shouldn't be able to focus on this container because it has nothing else to offer other than scrolling if terminal height/width is not sufficient) .

Here is my attempt:

class CanFocusOnlyWhenScrollbars(Widget, can_focus=False):
    """A Widget that can be focused only when any of it's scrollbars is active."""

    @on(Resize)
    def __enable_focus_only_when_scrollbar_is_active(self) -> None:
        self.can_focus = any(self.scrollbars_enabled)

but it doesn't work in all cases because the Resize message happens only under certain conditions (of course when resized :lol:, but looks like on the startup also) .

Any better ideas? I guess it would be much simpler to create if there were more Messages being posted (e.g. DescendantMount or DescendantUnmount - when things are mounted/unmounted to/from that widget, but there are no such messages. Maybe should be?)

Maybe there should be different modes? Like can_focus="always" , can_focus="never", can_focus="when_scrollbars"? But there will probably still be some situations that you would need to implement yourself. I think it's difficult now because there are no many messages published by textual by default. (like in my situation - when something happens to "our" widget - e.g. something is mounted / unmounted to it)

[davep]

Widget.show_horizontal_scrollbar and Widget.show_vertical_scrollbar are reactives that can be watched. I'd probably do something with that:

from textual import on
from textual.app import App, ComposeResult
from textual.containers import VerticalScroll
from textual.widgets import Button, Label

class MaybeFocus(VerticalScroll, can_focus=False):

    def watch_show_vertical_scrollbar(self) -> None:
        self.can_focus = self.show_horizontal_scrollbar or self.show_vertical_scrollbar

    def watch_show_horizontal_scrollbar(self) -> None:
        self.can_focus = self.show_horizontal_scrollbar or self.show_vertical_scrollbar

class FocusWhenScrollApp(App[None]):

    CSS = """
    Label {
        height: 5;
        background: red;
        width: 1fr;
    }
    """

    def compose(self) -> ComposeResult:
        yield Button("MORE!")
        yield MaybeFocus()

    @on(Button.Pressed)
    def more(self) -> None:
        self.query_one(MaybeFocus).mount(Label("Stuff"))

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

[mzebrak]

Unfortunately seems like this is not working well when we want the MaybeFocus just be a widget so it can be used as a base class for other widgets.

Consider:

class MaybeFocus(Widget, can_focus=False):
    def watch_show_vertical_scrollbar(self) -> None:
        self.__enable_focus_only_when_scrollbar_is_active()

    def watch_show_horizontal_scrollbar(self) -> None:
        self.__enable_focus_only_when_scrollbar_is_active()

    def __enable_focus_only_when_scrollbar_is_active(self) -> None:
        self.can_focus = any(self.scrollbars_enabled)


class Something(VerticalScroll, MaybeFocus):
    DEFAULT_CSS = """
    Something:focus {
        background: blue;
    }
    """

    def compose(self) -> ComposeResult:
        yield Label("Nothing yet")


class FocusWhenScrollApp(App[None]):
    CSS = """
    Label {
        height: 5;
        width: 1fr;
    }
    """

    def compose(self) -> ComposeResult:
        yield Button("MORE!")
        yield Something()

    @on(Button.Pressed)
    def more(self) -> None:
        self.query_one(Something).mount(Label("Stuff"))


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

This is not working right away because after startup you can focus the Something.

But marking a child with additional can_focus:

class Something(VerticalScroll, MaybeFocus, can_focus=False):
    ...

seems to be working, but isn't perfect either as you have to include that in every child.

(I don't want to override on_mount and perform such a check because later in every child i would need to call additional super().on_mount())

[davep]

Unfortunately seems like this is not working well when we want the MaybeFocus just be a widget so it can be used as a base class for other widgets.

Of course an illustration of an idea isn't a global solution, but I'm glad it helped you find something that worked for your application.

(I don't want to override on_mount and perform such a check because later in every child i would need to call additional super().on_mount())

Perhaps I'm missing something obvious here but that shouldn't be necessary.

from textual.app import App, ComposeResult
from textual.widgets import Static, Log

class Parent(Static):

    def on_mount(self) -> None:
        self.app.query_one(Log).write_line("This is from Parent.on_mount")

class Child(Parent):

    def on_mount(self) -> None:
        self.app.query_one(Log).write_line("This is from Child.on_mount")

class OnMountDefaultApp(App[None]):

    def compose(self) -> ComposeResult:
        yield Child()
        yield Log()

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

[mzebrak]

Damn, I missed that "Default behaviors" feature. So in this situation, it would be better to place it in on_mount. Thanks