Button2 | ESP button library that provides callback functions

I'm going to reply in Java, as I'm more familiar with it. The reasoning applies to kotlin too.

Bindings.createStringBinding(function, dependencies) creates a binding that is invalidated any time any of the dependencies are invalidated. Here "invalidated" means "changes from a valid state to an invalid state". The problem with your code is that you define the dependency as property.valueAt(index), which is a binding to which you have no other reference.

When you change either the index or the bean at that index in the list, then the binding becomes invalid. Since you never compute the value of that binding again, it never becomes valid again (i.e. it never holds, or has returned, a valid value). So subsequent changes will not change its validation state (it is simply still invalid; it cannot transition from valid to invalid).

Changing the code to

You are trying to change the inner working of a third party component. This is normally a bad practice. In this case probably the best way is to open a new issue on their Github repository. Ask them exactly what you need and maybe they will implement the requested feature for you.

Seeing the new state after a screen rotation (after a configuration change) is not related to how LiveData works. You are observing your LiveData correctly.

So i want that only the current State of my Array and no future states are pushed to my LiveData Objects so i gave it a copy of my Array.

A slight correction here, you gave it a shallow copy of your array. A shallow copy is a copy of the original array, but if the items are instances (references to objects), they will be copied by reference. Which means that changes on items in the copy of the array will affect the items in the original array as well, since it is the same references (= same instances).

And since you have an array of arrays, items in your array are instances of 4 other arrays. And when you change the values inside randomboard in your trySetValue function, you access the same 4 array instances every time.

The arrayOf calls create a new array instance and fill it with the values provided as parameters. So your initial assignment to randomboard creates 5 array instances:

• 4 are of type Integer[] and contain values 0, 0, 0, 0
• 1 is of type Integer[][] and contains references to the 4 arrays above. The reference to this array is stored into the field randomboards

This snippet of code compares the values by reference and shows that the main array is a new instance (because of the copyOf call), but the arrays inside are the same instances.

I forgot the fm.popBackStackImmediate(); in the onBackPressed() method in the MainActivity.java. Which, when actually placed in onBackPressed() made everything work perfectly.

Like a lot of problems with SwiftUI, this seems overly complex because you're mixing the concept of state with how that state is drawn on screen.

Removing the visuals for a moment, what you have in terms of data is:

• an ordered collection of pages, each with a title and image
• a concept of which page in that collection is active

(Note that I call them 'pages' here to try and separate them from the visual representation as tabs.)

You also have some actions which will alter that data:

• your user can choose which page should be the active one
• they can add a new page to the collection
• they can remove an existing page from the collection

Now, if you think of those small steps as your data model, you can build an object or objects which cleanly encapsulate that.

Then, you can go on to determine how SwiftUI represents that data and how it might include the action triggers. For example:

• A list of horizontal tabs loops through the ordered collection of pages and renders each one
• Each tab has a button action which, when tapped, sets that button to be the active one
• Each tab has a close button which, when tapped, removes it from the pages collection
• A separate button, when tapped, can add a new page to the collection

And so on. Hopefully, you can see that each view in SwiftUI would now have a specific purpose, and should be easier for you to think about.

And you might even decide on a different UI – you could list your pages vertically in a List, for example, or in a grid like the iPhone's Safari page view. But even if you did, your underlying data wouldn't change.

First of all, if you remove all the unrelated code from your example, we get this MCVE:

Add all the buttons to a QButtonGroup (using their index as id) and then connect to the group's idClicked signal. This will automatically send the index of the clicked button. Below is a simple demo that shows how to do it:

The problem is you are changing the input.value to bold. You can't style the input.value you should directly change the input style.

Also, you can't use the input.value = it is not built-in function like toUpperCase, it is style.

Use input.value.style.fontWeight may work, but you need to apply it back which click on other element which is messy. The easiest way is to so you don't have to worry to change it back.

The problem with your approach is that it is recursive. beginning invokes game, game invokes game_over and game_over again invokes beginning: