All language subtitles for 32. Passing Callback Functions Aroundf

We had a look at some of the widgets we can use and at the widget catalog and of course throughout the course,

we'll use loads of the widgets you saw there,

so no need to learn it by heart right now. For the moment however, I want to move on by now also moving

my buttons here, my answer buttons into a separate widget, into a custom widget.

Maybe change the styling a little bit, maybe to give them a blue background and make them take the full

available width but that won't be the the focus here,

instead what I want to make sure is that

we have real text on these buttons, so that we have text that fits to the question we have here,

so that we continue working on this first basic application. And for this, let's create a new answer.dart

file which should hold the answer widget

and there we need to create a widget now.

Now you could think that you need to create a stateful widget now,

right

because here in main.dart, on a button we of course have that onPressed argument to which we pass a

pointer to the answer question function.

Now just because we register a function here for an event does not mean that the RaisedButton has to

be in a stateful widget.

Of course we want to change some data when this event fires, when the user presses the button

but as it turns out, we can also trigger a function in another place of the app even if this button lives

in a separate widget

and that is a core concept and a core pattern which you will use a lot in Flutter and therefore it's exactly

the pattern we'll dive in right now.

So here in the answer.dart file, I'll create a new stateless widget here actually and I will name

it answer

and just as in the question widget, we need to import the material file from the Flutter package because

that unlocks stateless widget and so on.

Now in here, I will leave the container because as a child of that container, I want to have my button

and I keep the container because that will allow me to control the width.

So here, the child is the RaisedButton here,

the text will soon be received from outside

and I'll come back to that and onPressed as I said should change something but will also make that

change in another widget and how that works is also something I'll show you in a second.

First of all, let's adjust the width and I'll set it to double infinity again, which is a helper property

on the double object.

Remember, everything in Dart is an object,

so are doubles and that is the core double type which at the same time is basically the class

for the double value you could say

and on this class we have an infinity property which basically gives us a value which tells the container

to take as much width as it can get, which is the width of our device.

So that's the width of the container,

now for onPressed I'll temporarily use null again so that we don't get an error and that we now can

use this button as it is.

I also want to set the color of the button here and I will set it to a color by accessing colors and

colors actually is a class which also has some so-called static properties,

these are properties which you can directly use on the class itself without instantiating it first

and there you have various preconfigured colors and I will simply use blue.

Now this can look strange because we haven't used that before, a static property in the end simply as

I said is a property which you can use without instantiating class.

If we have a look at the source code here, we see that the class here has these static const values, const

is something we haven't seen before,

let's ignore it for now, these static const values here, like black and then a different shade of black

and so on

and then if we scroll down, also different shades of white.

So these are simply properties, normal properties on the class,

the only difference is that you can access them without creating an instance of the class first and

such properties exist because we need that value here, right

and therefore, this is like a utility feature of Dart

you could say, that we can get easy access to such a value without having to create a new instance. Instances

of classes typically makes sense if you want to create multiple different objects based on one and the

same class.

Here of course we want to have multiple different colors but each color is just a value, like a

simple text or so on and therefore of course technically, it's also an object but we don't need

the complex colors object for that. Colors in

the end is just like a group of predefined single colors

you could say, so this colors class here exists not to be instantiated because colors itself, this object,

that doesn't do anything, it just exists as a grouping mechanism around preconfigured values. A little

bit like an enum but an enum simply gives numbers 0, 1, 2, a label, a human readable label. Here, the idea

is to have a human readable label for a more complex value you could say because the value here is not

just a number but actually the hex code or the binary representation of a color.

So that is what we're doing here, we're getting access to this static property here on the colors class

and this will give us the internal color value which Dart and Flutter can use to color this button

and with all of that, we can use the answer widget here in the main.dart file. For that,

let's first of all add an import,

you always need to import what you want to use in a file because since the answer widget lives in a

different file, in order to use it in the main.dart file, we have to import it there

and then with it imported, we can replace our RaisedButton here with answer

and now here of course we create concrete instances of our answer widget class because we want to create

widget objects, multiple different widget objects, which we can use here

and that should be an answer not answers here.

Now with that if we save this, we now have our buttons there. Now

they are greyed out because at the moment, they're all locked, disabled because I haven't assigned a real

function to onPressed and that will be the next step and here,

the tricky thing will be that this function which I want to assign here actually lives in the main.dart

file because that is where I manage my question index and I have to manage the question index there because

I also have my questions in here and I need to have my questions in here because I want to pass them

down to the question widget which has no direct connection to the answer widget. So we can't manage the

question index in the answer widget because if we would do that, then we would have the value in here

but then again we couldn't use it to select a question here which we want to forward to the question

widget.

So our main.dart file is the common denominator you could say, the shared widget between the answer and

the question widget because our main.dart file and the widget in there, the MyApp widget, that is the

parent widget of question and answer, it is the widget that instantiates and uses question and answer

and therefore we want to manage our state which both components need or which both widgets need, we want

to manage that state here in the MyApp component or in MyApp widget and therefore also in MyAppState

which is connected to that widget.

This concept is called lifting the state up, you manage the state on the shared, on the common denominator

of the different widgets that need this state and that is the direct parent of these widgets that need

the state.

So since we manage the state in here, we also have the function to change the state in here, in the MyAppState

class

but how do we now get access to the answer question function in our answer widgets here?

The answer is pretty simple. Just as we can pass text to a widget, we can also pass a pointer at a

function to a widget.

So answer question,

my function here can be forwarded to the answer widgets, without parentheses because I don't want to

execute my answer question function immediately when Dart reads this,

instead I want to forward the pointer at this function to my answer widget. And now in the answer widget,

we of course need to accept this as our argument to the constructor because the answer widget here, that

in the end is just a class right and

therefore it can have a constructor.

So here, we can add a constructor by repeating the class name and I'll use that shortcut for the constructor

and I will also add a property here,

a final property, the type now is function which is built into Dart and as the name suggests,

this means that the values stored in this property has to be a function or a pointer at a function

to be precise

and therefore here now, you can give this any name you want, I'll name this selectHandler, whatever you

want to name it

and in my answer constructor, I now store whatever I get here in selectHandler.

Now what I do get in here

in my answer constructor is a pointer at the answer question and this pointer is stored in this property.

in my answer class and function simply means that what is stored here has to be a pointer at a function.

And now since we have that pointer at a function, which is exactly what I need down there, I can use select

handler here. Again, without parentheses because the same thing as explained earlier still applies,

we don't want to execute this immediately and hence now we should have a setup where we can trigger

a function that's actually defined in a different widget from inside our answer widget because we pass

a reference to that function down to the answer widget here in our MyAppState. So with this set up,

we should be able to save this

and now if I press a button here, indeed our text here changes, which means that this communication

between parent and child works.