Updating TextInput on switch/button on_toggle & off_toggle

[AnkS4]

How do I implement TextInput update multiple times?

Ex.

def incremental(self, widget):
        for i in range(10):
            time.sleep(2)
            self.transcription_output.value = i

switch = toga.Switch(
            label="TEST",
            is_on=False,
            on_toggle=self.incremental,
            )

This one is only getting updated at the end instead of at each assignment.

Also, how do I update TextInput when it's off toggle? I haven't found any attribute similar to off_toggle.
Is there any other widget which I can use to update the text multiple times?

[freakboy3742]

The update behavior you're seeing needs a little explanation, but it comes down to "When are you giving the GUI toolkit an opportunity to update itself?" You're not - and as a result, the widget isn't updating.

You may have noticed that you start an app by invoking a main_loop() method - that main loop is the event loop. It's essentially a tight loop that say "while App Running: redraw app" (it's a little more complex than that in practice, but it's close enough for this explanation). When you're not interacting with it, the app is constantly redrawing in the background; whenever an event occurs (like a button click), your handler is queued into the event loop for execution. However, the app is single-threaded - so if the app is in your code code, it's not redrawing the app.

So - in your case, you're pressing a switch, which is invoking a handler, the handler is modifying an output... but you're never giving control back to the app to run the event loop, and as a result, the app never gets an opportunity to redraw to reflect that change. When the handler finishes, the app can now redraw, and it reflects the current state of the app - the final value that you assigned.

You may have notice apps that "beachball" or throw up a "non-responsive" message of some kind. That's essentially the same thing that is happening here - the operating system is telling you that your app hasn't called the redraw function for a while. This usually happens when some form of IO (e.g., network or disk access) takes longer than the programmer expected, and the app locks up waiting for that IO to complex. If you increase the number of loops in your handler, to 100, I'd wager you will see your app "beachball", because the operating system will notice that it hasn't had a chance to update the GUI for a while.

This isn't a Toga specific thing either - essentially every GUI toolkit works in a very similar way.

The fix is to release control to the app on a regular basis so it has a chance to redraw. You've even got a convenient point to do that release - you're sleeping for 2 seconds. There's no reason your handler needs to retain control of the app for those 2 seconds - so you can tell Toga that you'd like to release control to the app for 2 seconds, and resume once that is done.

Toga has 2 ways you can do this. Firstly, you can modify the handler to be a generator; any value yielded by the generator will be interpreted as the duration that you'd like to release control:

def incremental(self, widget):
        for i in range(10):
            yield 2
            self.transcription_output.value = I

The other approach is to make the handler an async co-routine, and asyncio.sleep(), rather than time.sleep().

import asyncio

async def incremental(self, widget):
        for i in range(10):
            await asyncio.sleep(2)
            self.transcription_output.value = I

As a general rule, you need to ensure that any code you write, especially in handlers, will complete as fast as possible, so that your app doesn't lock up. That means breaking your logic into smaller pieces, providing regular release opportunities for the app to redraw. yield 0 is an option - you just need to release control so the app can clear any pending events, then resume processing; or, you can use asyncio APIs instead of synchronous APIs.

As for the second question - "on_toggle" doesn't mean "when toggled on", it means "on a toggle event". You should get a toggle with both the on and off change; you can use the current is_on value of the toggle widget to determine if it's on or off.

[AnkS4]

How can I check if the switch/button has is_on value True/False from increment function?

I need to run a function until user interruption i.e. until the button/switch is turned off. What would be the ideal way to do it?

[freakboy3742]

if my_switch.is_on: will tell you if the switch is currently on. If you want something to run until a switch is turned off, you can put the logic into the on_toggle handler:

def my_toggle_handler(widget, **kwargs):
    while widget.is_on:
        do_thing()
        yield 2

This method will be invoked on both the "on" and "off" transition. When the widget turns on, the loop will start and keep running, until the button turns off. When the button turns off, the handler will be invoked a second time - but it won't do anything, because the while loop will immediately exit.

If you want to do this with a start/stop button rather than a switch, you can do a very similar thing, except that you need to create the "is running" state variable yourself.