All language subtitles for 20. Splitting the App Into Widgets

Let's add a stateful widget. Now which widget should be stateful?

Right now we only have one widget,

the widget in our main file.

We could turn this into a stateful widget but that would have at least two disadvantages which are

kind of connected.

For one, it's already a pretty large widget,

we have a pretty complex widget tree in there and it is a good practice and good idea to split your

large widgets into smaller widgets,

that makes it easier to read them, to work on them, to maintain them

and also from a performance perspective, as soon as you start having stateful widgets that also rebuild

when you change something, you should split your app so that you don't rebuild your entire widget tree

just because a transaction changed.

For example here, the part where we handle the user input, that is where we get the data for the new transaction

but of course this box up here doesn't change just because we added a new transaction, in this box

we don't show the new transaction

so there is no need to repaint this with every new transaction we added or with every change in the

transactions list in general.

So it would make sense to kind of have that list of transactions in a separate widget and therefore

let's create a new file here which I'll name transaction_list.dart.

Now in addition, I now also want to make it really clear which files here are widgets and which files

are normal classes,

for example the transaction.dart file is a normal class, it's not a widget at all.

This here, the transaction class serves as a model for our data and

therefore here, I'll create a new folder, models and move the transaction.dart file in there

and if we had more models, if we had different types of data, different custom types, we would also add

them here.

In the main.dart file, I now also have to adjust my import here and import from

./models.transaction.dart because I moved that file in there.

Now the transaction list on the other hand is a widget and therefore, I'll also create a new subfolder,

widgets.

Now here I'll move the transaction_list.dart file into the widgets folder.

Now of course right now it might look a bit overkill to have two folders for only two files but the

more widgets we add, the more sense the separation makes because it's then way easier for us to find

out what's a widget and what's a model.

So in the transaction list file here, I want to create a new stateful widget now and for this, I'll use

the shortcut here,

this little snippet the Flutter extension gives me in Visual Studio Code to scaffold out a stateful

widget, it automatically creates the widget class and the state class and it places a couple of markers

where you can now type the name and it inserts the name in all the places that need it.

So here, I'll name this transaction list, using this pascal case naming convention of having uppercase

starting characters for the words but having only one word altogether.

Now in here, I need to import material.dart from the Flutter package because we're using stateful

widget which is exposed by that package, also the state is coming from there

and of course build context, the widget type and the container type here and with all of that, we have

our base widget setup. Now in here,

I want to manage my list of transactions,

so with that I mean my list of transaction objects. In here, we can therefore add a final list of transactions

and for that, make sure you add an import to your transaction model with

../models/transactions,

dot dot because we need to go up one level where in the widgets folder, dot dot tells Dart to go up

one level,

so out of the widgets folder and then it looks for a new folder, models which then exists in that lib

folder in which we then are and there, in the models folder, it gets access to the transaction.dart

file.

So then we have a list of transactions here and I'll name this user transactions, any name you want and

initially,

I'll have the transactions in here which we previously had in the main.dart file.

So let's grab these two transaction objects here,

cut them in the main.dart file and move them into the transaction list, like this.

So now we have these two dummy transactions here to start with,

by the way if you're wondering why this is final, we will still be able to edit this list as you will

see

and I will come back to why this works and how it works in a second.

So now we have these two transactions in here, now in the build method

here, I of course want to build that list of transaction widgets. In the main.dart file,

I can get rid of that transaction list and also get rid of that input here from the models folder

of course

and if we scroll down to that error which my IDE displays, this is the part where I output the list of

transactions, this is the part which we can grab

now, this entire column here,

cut it out of the main.dart file and of our widget there and add it instead as the return value in our

transaction list here. Now in there,

I'm accessing date format and date format

on the other hand requires us to import the intl package, so we can remove that import from the

main.dart file and add it here in the transaction_list.dart file so that we can format the date and transactions,

that's the wrong property name, here

I renamed it to _userTransactions

should be the name,

so _userTransactions,

so let's use this here.

Now we have the transactions managed in here but now we'll face a new problem,

we're adding transactions from inside our card here with the text fields and that card is actually a

sibling to our transaction list widget which we would add here.

So add transaction list here next to the card,

that's why these ending annotations which the Flutter extension adds are really useful,

so next to the card where you have your text fields and of course to use the transaction list widget

here, you have to import it from ./widgets/transaction_list.dart.

But as I just said, we now have a problem because in transaction lists, we have our list of transactions

and this list should change

but the change is triggered by our text fields which reside in the main.dart file.

So what can we do about that? Well in the end, we have to do something which is called lifting state up,

which means the common denominator of our text field card here and of the transaction list,

so the one widget where we use them both is of course still my homepage widget here.

So there actually is no way around managing our own state, our transactions in here because we need to add

a new transaction to that list from inside our text fields here or with the help of our text fields

and then we need to pass that down to the transaction list which is nice for outputting our transactions

but bad for managing them because if we manage our transactions here in transaction list, then we have

no way of accessing the user transactions list here from outside of that transaction list widget,

the problem just is our text fields here are not inside of the transaction list.

So of course we could alternatively also take that card with all the text fields and add it to our transaction

list,

that would work

but I actually prefer a different approach.

Let's add two new widgets - one for our text input area here,

so for the card with the text fields simply to make that main widget tree a bit leaner and second, let's

then put our text input widget which we'll create

and that transaction list widget,

let's put that together into a new third widget which we then use here in the main widget, in

MyHomePage widget.

The advantage of this will be that the MyHomePage widget can stay stateless and things like the scaffold

and the app bar aren't rebuilt

just because we added a new transaction, because these things really are not affected by a new transaction.

The parts that do need to interact with a new transaction,

so our text input card here and the transaction list will then live in a separate widget.

So let's add two new widgets as I just said,

one is the new_transaction.dart file which will hold our text fields and one is the

user_transactions.dart file. In the new_transaction.dart file, I'll create a stateless

widget which I'll call new transaction and in here, as in all your widget files, you need to import

material.dart so that you unlock stateless widget and so on.

Now let's go back to the main.dart file and grab that card with all the text fields in there,

so this entire card here, grab it, cut it, remove it from the main.dart file and return it here in the

new transaction file.

Now we have the amount and the title controller in here,

so let's add that, let's add these properties in the new transaction widget. The title controller is a

text editing controller, so instantiate that and store it in a final property and the same for the amount

controller,

that's the exact same step we did in the main file earlier.

So now this works, now in the main.dart file,

we can simply use our new transaction widget here, instantiate it and add an import at the top.

Again my IDE automatically added one and whilst this would work, the recommended syntax actually is used

as relative import syntax with ./widgets/new_transaction in this case

and now we have a leaner main.dart file.

Now to avoid having to manage the state in here for these two widgets where actually at the moment,

MyHomePage is the common denominator, to avoid having to manage them here,

we have that new user transactions file here.

That will now hold a stateful widget named user transactions, where as always, you have to import

material.dart

and now here, I actually want to use my new transaction and my transaction list widget.

So the goal here is to return a simple column with these two widgets, actually

basically what we have here,

a column with these two widgets. So you can cut the two widgets here from main.dart file and therefore

also of course get rid of these import statements there and instead in the user transactions file, return

a column because we want to have two widgets sit on top of each other, hence we need a column and in that

column,

add these two widgets and of course also add the imports, so import ./new_transaction.dart and

import ./transaction_list.dart.

Now we can manage our list of transactions here in the user transactions state,

so in the transaction_list.dart file,

we actually don't need a stateful widget,

instead let's use a stateless widget here

and that means we can get rid of this part of the create state

method here and then also of our state class. Cut that list of transactions here, leave the build method

in here of course, we still need that but now go to the user transactions file and there to the user

transaction state and add that _userTransactions property there.

Here I'm also using the transaction type, my transaction model,

so we have to go out of the widgets folder to the models folder and then import my transaction.dart

file here.

Now we're almost there but now we need to pass user transactions to the transaction list widget here

and you learned how that works.

So feel free to do it on your own,

we'll do that and a couple of other things in the next lecture.