Created
November 9, 2021 14:24
-
-
Save noga-dev/c1f5315c64af0a0119b9b594eb5d6aca to your computer and use it in GitHub Desktop.
test code for blockman
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Want to support my work 🤝? https://buymeacoffee.com/vandad | |
import 'package:flutter/material.dart'; | |
class ListItem { | |
const ListItem(); | |
factory ListItem.emptyTile() => EmptyTile(); | |
factory ListItem.tile( | |
String title, | |
String subTitle, | |
) => | |
Tile( | |
title, | |
subTitle | |
); | |
} | |
class Tile extends ListItem { | |
final String title; | |
final String subTitle; | |
const Tile(this.title, this.subTitle) : super(); | |
} | |
class EmptyTile extends ListItem {} | |
final items = [ | |
for (var i = 1; i <= 6; i++) ListItem.tile('Title $i', 'Sub title $i'), | |
ListItem.emptyTile(), | |
for (var i = 7; i <= 12; i++) ListItem.tile('Title $i', 'Sub title $i'), | |
]; | |
class Background extends StatelessWidget { | |
final Widget child; | |
const Background({Key? key, required this.child}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Container( | |
clipBehavior: Clip.antiAlias, | |
decoration: BoxDecoration( | |
borderRadius: BorderRadius.circular(20), | |
image: const DecorationImage( | |
fit: BoxFit.fitHeight, | |
image: NetworkImage('https://bit.ly/3jXSDto'), | |
), | |
), | |
child: child, | |
); | |
} | |
} | |
class HomePage extends StatelessWidget { | |
const HomePage({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage2 extends StatelessWidget { | |
const HomePage2({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage3 extends StatelessWidget { | |
const HomePage3({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage4 extends StatelessWidget { | |
const HomePage4({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage5 extends StatelessWidget { | |
const HomePage5({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage6 extends StatelessWidget { | |
const HomePage6({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage7 extends StatelessWidget { | |
const HomePage7({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage8 extends StatelessWidget { | |
const HomePage8({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage9 extends StatelessWidget { | |
const HomePage9({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage10 extends StatelessWidget { | |
const HomePage10({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage20 extends StatelessWidget { | |
const HomePage20({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage30 extends StatelessWidget { | |
const HomePage30({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage40 extends StatelessWidget { | |
const HomePage40({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage50 extends StatelessWidget { | |
const HomePage50({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage60 extends StatelessWidget { | |
const HomePage60({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage0 extends StatelessWidget { | |
const HomePage0({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage790 extends StatelessWidget { | |
const HomePage790({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage770 extends StatelessWidget { | |
const HomePage770({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage90 extends StatelessWidget { | |
const HomePage90({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage80 extends StatelessWidget { | |
const HomePage80({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage70 extends StatelessWidget { | |
const HomePage70({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage100 extends StatelessWidget { | |
const HomePage100({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage200 extends StatelessWidget { | |
const HomePage200({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage300 extends StatelessWidget { | |
const HomePage300({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage400 extends StatelessWidget { | |
const HomePage400({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage500 extends StatelessWidget { | |
const HomePage500({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage600 extends StatelessWidget { | |
const HomePage600({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
), | |
); | |
} | |
} | |
class HomePage7500 extends StatelessWidget { | |
const HomePage7500({Key? key}) : super(key: key); | |
@override | |
Widget build(BuildContext context) { | |
return Scaffold( | |
body: Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: | |
(context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets | |
.zero, | |
itemCount: items | |
.length, | |
itemBuilder: | |
(context, | |
index) { | |
final item = | |
items[ | |
index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView | |
.builder( | |
padding: | |
EdgeInsets.zero, | |
itemCount: | |
items.length, | |
itemBuilder: | |
(context, index) { | |
final item = | |
items[index]; | |
if (item | |
is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
Background( | |
child: ListView.builder( | |
padding: EdgeInsets.zero, | |
itemCount: items.length, | |
itemBuilder: (context, index) { | |
final item = items[index]; | |
if (item is Tile) { | |
const Background( | |
child: SizedBox(), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: | |
ListTile( | |
title: | |
Text(item.title), | |
subtitle: | |
Text(item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: | |
450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors | |
.grey[200], | |
child: ListTile( | |
title: Text( | |
item.title), | |
subtitle: | |
Text(item | |
.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: | |
Text(item.title), | |
subtitle: Text( | |
item.subTitle), | |
), | |
); | |
} else if (item | |
is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} else if (item is EmptyTile) { | |
return const SizedBox( | |
height: 450, | |
); | |
} else { | |
throw 'unexpcted item'; | |
} | |
}, | |
), | |
); | |
return const SizedBox(); | |
} | |
throw 'unexpcted item'; | |
}, | |
), | |
); | |
return Container( | |
color: Colors.grey[200], | |
child: ListTile( | |
title: Text(item.title), | |
subtitle: Text(item.subTitle), | |
), | |
); | |
} | |
print('test'); | |
print('test'); | |
throw 'unexpcted item'; | |
}, | |
), | |
); | |
return const SizedBox(); | |
} | |
throw 'unexpcted item'; | |
}, | |
), | |
), | |
); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment