Das Schreiben eigener Widgets steht im Mittelpunkt der Arbeit mit [Flutter]: Ein gut geschriebener Bildschirm besteht aus kleinen Widgets, jedes mit eigenen Parametern, seinem [build] und gegebenenfalls seinem Zustand. Dieses Kapitel zeigt, wie sie miteinander kommunizieren (Parameter, Funktionen), wie sie zusammengesetzt werden (Komposition), wie sie funktionieren (Lebenszyklus), wie sie Daten teilen, ohne sie von einem zum anderen weiterzureichen (vererbte Daten), und wie sich Verhalten wiederverwenden lässt.
4.1.1. Datentyp
Eltern- und Kind-Widget teilen sich eine Klasse, die in einer eigenen Datei definiert ist:
| // der vom Eltern-Widget (DoctorsPage) und vom Kind (DoctorCard) geteilte Datentyp
class Doctor {
final int id;
final String title;
final String firstName;
final String lastName;
final String specialty;
final bool available;
const Doctor({
required this.id,
required this.title,
required this.firstName,
required this.lastName,
required this.specialty,
required this.available,
});
// eine Kopie, in der sich nur die Verfügbarkeit ändert
Doctor withAvailability(bool d) =>
Doctor(id: id, title: title, firstName: firstName, lastName: lastName, specialty: specialty, available: d);
}
|
- Zeilen 10–16: ein Konstruktor mit benannten Parametern, die alle erforderlich sind: [Doctor(id: 1, title: 'Mme', ...)]. Benannte Parameter machen den Aufruf lesbar, und ihre Reihenfolge spielt keine Rolle;
- Zeilen 20–21: eine Kopie, in der sich nur die Verfügbarkeit ändert (das Objekt selbst ändert sich nie).
4.1.2. Das Kind
| // =========================================================================
// lib/ex10_widget_parameters/doctor_card.dart - ein KIND-Widget
// -------------------------------------------------------------------------
// Es erhält seine Daten von seinem Eltern-Widget über die PARAMETER seines
// Konstruktors, abgelegt in final-Feldern. Ihr Typ wird zur
// Kompilierzeit geprüft: DoctorCard(doctor: 42) würde abgelehnt.
// - required: Das Eltern-Widget MUSS diesen Parameter angeben;
// - this.compact = false: ein optionaler Parameter mit seinem Standardwert.
//
// Goldene Regel: Ein Widget ÄNDERT NIE seine Parameter (sie sind final).
// Die Daten fließen vom Eltern-Widget zum Kind; um eine
// Änderung anzufordern, ruft das Kind eine Funktion auf, die das Eltern-Widget ihm übergeben hat
// (siehe Beispiel 11). Wenn das Eltern-Widget seine Daten ändert, BAUT es
// seine Kinder mit neuen Parametern NEU.
// =========================================================================
import 'package:flutter/material.dart';
import 'doctor.dart';
// der "Stil" der Karte: Konstanten, die PRIVAT für diese Datei sind (das "_").
// Kein anderes Widget kann sie sehen, noch von ihnen gestört werden
const _initialsColor = Color(0xFF087EA4);
const _initialsStyle = TextStyle(color: Colors.white, fontWeight: FontWeight.bold);
class DoctorCard extends StatelessWidget {
final Doctor doctor;
final int rank;
final bool compact;
// const: Wenn alle Parameter konstant sind, ist es das Widget auch
// (Flutter muss es dann nicht einmal neu bauen)
const DoctorCard({super.key, required this.doctor, required this.rank, this.compact = false});
@override
Widget build(BuildContext context) {
// ein aus den Parametern berechneter Wert
final initials = '${doctor.firstName[0]}${doctor.lastName[0]}';
return Card(
// ein grüner Rand für einen verfügbaren Arzt
shape: RoundedRectangleBorder(
borderRadius: BorderRadius.circular(12),
side: doctor.available ? const BorderSide(color: Colors.green, width: 2) : BorderSide.none,
),
child: Padding(
padding: const EdgeInsets.all(12),
child: Row(
children: [
CircleAvatar(
backgroundColor: _initialsColor,
child: Text(initials, style: _initialsStyle),
),
const SizedBox(width: 12),
// Expanded: Der Text nimmt die gesamte verbleibende Breite ein
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'$rank. ${doctor.title} ${doctor.firstName} ${doctor.lastName}',
style: Theme.of(context).textTheme.titleMedium,
),
if (!compact) Text(doctor.specialty, style: const TextStyle(color: Colors.grey)),
],
),
),
],
),
),
);
}
}
|
- Zeilen 23–24: der „Stil“ der Karte: Konstanten, die privat für diese Datei sind (das „_“). Keine andere Datei kann sie sehen oder von ihnen beeinflusst werden. Das ist in [Flutter]das Äquivalent der „CSS-Module“ in [React]: Es gibt kein globales Stylesheet; der Stil eines Widgets ist in seinen Code eingebettet;
- Zeilen 27–29: die Parameter des Widgets, gespeichert in [final]-Feldern;
- Zeile 33: der Konstruktor. [required this.doctor]: ein erforderlicher Parameter, direkt im Feld gespeichert; [this.compact = false]: ein optionaler Parameter mit seinem Standardwert. Der Konstruktor ist [const]: Sind alle Argumente konstant, ist auch die Karte konstant;
- Zeile 38: ein aus den Parametern berechneter Wert;
- Zeilen 42–44: die Form der Karte ([Card]): abgerundete Ecken und ein grüner Rand, wenn ein Arzt verfügbar ist ([BorderSide.none] andernfalls);
- Zeilen 50–52: eine farbige Scheibe mit den Initialen;
- Zeile 64: Die Fachrichtung wird nur in der nicht kompakten Ansicht angezeigt.
Goldene Regel: Ein Widget ändert niemals seine eigenen Parameter (sie sind [final]; der Compiler verbietet dies übrigens). Die Daten fließen vom Eltern- zum Kind-Widget; um eine Änderung anzufordern, ruft das Kind eine Funktion auf, die ihm das Eltern-Widget übergeben hat (Beispiel 11). Ändert das Eltern-Widget seine Daten, baut es seine Kinder mit neuen Parametern neu auf.
| // =========================================================================
// lib/ex10_widget_parameters/main.dart - das ELTERN-Widget
// -------------------------------------------------------------------------
// Es importiert das Widget DoctorCard und verwendet es, so oft
// nötig, wie jedes Flutter-Widget: Ein Widget ist ein Stück
// WIEDERVERWENDBARE Oberfläche mit eigenen Parametern, seinem build() und
// seinem Stil. Eigene Widgets zu schreiben ist das Herzstück der Arbeit mit
// Flutter: Ein gut geschriebener Bildschirm besteht aus kleinen Widgets.
// =========================================================================
import 'package:flutter/material.dart';
import 'doctor_card.dart';
import 'doctor.dart';
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const DoctorsPage(),
),
);
}
class DoctorsPage extends StatefulWidget {
const DoctorsPage({super.key});
@override
State<DoctorsPage> createState() => _DoctorsPageState();
}
class _DoctorsPageState extends State<DoctorsPage> {
List<Doctor> _doctors = const [
Doctor(id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner', available: true),
Doctor(id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician', available: false),
Doctor(id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner', available: true),
];
bool _compact = false;
// Das Eltern-Widget ändert SEINE Daten: Flutter ruft sein build() erneut auf, was
// die Kinder mit ihren neuen Parametern neu baut
void _toggleAvailability() {
setState(() {
_doctors = [for (final m in _doctors) m.withAvailability(!m.available)];
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Example 10 - the widgets and their parameters')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
SwitchListTile(
contentPadding: EdgeInsets.zero,
title: const Text('compact display'),
value: _compact,
onChanged: (v) => setState(() => _compact = v),
),
Align(
alignment: Alignment.centerLeft,
child: OutlinedButton(onPressed: _toggleAvailability, child: const Text('Toggle the availabilities')),
),
const SizedBox(height: 8),
for (final (i, m) in _doctors.indexed)
// jede Karte erhält IHRE Parameter
DoctorCard(key: ValueKey(m.id), doctor: m, rank: i + 1, compact: _compact),
const SizedBox(height: 16),
const Text(
'The same card, in its compact version, by setting the parameter:',
style: TextStyle(color: Colors.grey),
),
SizedBox(width: 260, child: DoctorCard(doctor: _doctors[0], rank: 1, compact: true)),
],
),
);
}
}
|
- Zeilen 34–39: der Zustand des Eltern-Widgets: die Liste der Ärzte (eine konstante Liste, die durch eine andere ersetzt wird) und die kompakte Anzeige;
- Zeilen 43–45: Das Eltern-Widget ändert SEINE Daten zu einer neuen Liste, die aus Kopien der Ärzte besteht. [Flutter] ruft sein [build] auf, das die Karten mit ihren neuen Parametern neu aufbaut;
- Zeile 69: eine Karte pro Arzt, mit SEINEN Parametern. Das Widget [DoctorCard] wird genau wie ein [Flutter]-Widget verwendet;
- Zeile 75: dieselbe Karte in einer kompakten Version, in einem Kasten von 260 Punkten Breite.
Zunächst und dann in der kompakten Ansicht wird die Verfügbarkeit umgekehrt:
Eine Methode, die Widgets erzeugt (wie [_line] aus Beispiel 02), oder ein echtes Widget ([DoctorCard])? Das echte Widget ist fast immer vorzuziehen: Es hat einen Namen, seine Parameter sind typisiert und dokumentiert, es kann an anderer Stelle wiederverwendet werden, und [Flutter] kann den Neuaufbau vermeiden (wenn es [const] ist oder sich seine Parameter nicht geändert haben).
Daten fließen über Parameter nach unten; Informationen fließen über Funktionen, die als Parameter übergeben werden, wieder nach oben.
4.2.1. „Ereignisse“ des Kindes
| // =========================================================================
// lib/ex11_lifting_state_up/counter.dart
// -------------------------------------------------------------------------
// Ein Kind, das sein Eltern-Widget BENACHRICHTIGT: Das Eltern-Widget übergibt ihm FUNKTIONEN als
// Parameter (per Konvention beginnt ihr Name mit "on"), und das Kind
// ruft sie auf, wenn etwas passiert:
// Counter(label: 'Coffees', max: 3, onIncrement: ..., onLimit: ...)
// Die Typen dieser Funktionen haben in Flutter vorgefertigte Namen:
// - ValueChanged<int> : eine Funktion, die ein int erhält und nichts zurückgibt;
// - VoidCallback : eine Funktion ohne Parameter, die nichts zurückgibt.
// =========================================================================
import 'package:flutter/material.dart';
class Counter extends StatefulWidget {
final String label;
final int max;
final ValueChanged<int> onIncrement; // mit dem neuen Wert
final VoidCallback onLimit; // ohne Daten
const Counter({
super.key,
required this.label,
required this.max,
required this.onIncrement,
required this.onLimit,
});
@override
State<Counter> createState() => _CounterState();
}
class _CounterState extends State<Counter> {
// der für diesen Zähler SPEZIFISCHE Zustand: Jeder Counter hat seinen eigenen
int _value = 0;
void _plus() {
// widget: im State-Objekt, gibt Zugriff auf die Parameter des Widgets
if (_value >= widget.max) {
widget.onLimit();
return;
}
setState(() => _value++);
// Das Eltern-Widget wird BENACHRICHTIGT und erhält den neuen Wert
widget.onIncrement(_value);
}
@override
Widget build(BuildContext context) {
return Row(
children: [
SizedBox(width: 110, child: Text(widget.label)),
OutlinedButton(onPressed: _plus, child: const Text('+1')),
const SizedBox(width: 12),
Chip(label: Text('$_value / ${widget.max}')),
],
);
}
}
|
- Zeilen 18–19: zwei Parameter, die Funktionen sind und die der Zähler aufrufen wird. [ValueChanged<int>] ist der Typ einer Funktion, die einen [int] entgegennimmt und nichts zurückgibt; [VoidCallback] ist der Typ einer Funktion ohne Parameter. Per Konvention beginnen ihre Namen mit „on“, etwa [onPressed] oder [onChanged] bei den Widgets von [Flutter];
- Zeile 35: der für diesen Zähler SPEZIFISCHE Zustand: Jeder [Counter] hat seinen eigenen;
- Zeilen 37–45: Innerhalb des [State]-Objekts [widget] ermöglicht den Zugriff auf die Einstellungen des Widgets: [widget.max], [widget.onLimit]... Wird das Maximum überschritten, benachrichtigt der Zähler sein Eltern-Widget ([widget.onLimit()]); andernfalls ändert er seinen Zustand und benachrichtigt dann sein Eltern-Widget, indem er den neuen Wert übermittelt. Anders als in [React]wird der Zustand sofort aktualisiert: [_value] hat bei der Übermittlung bereits seinen neuen Wert.
| // =========================================================================
// lib/ex11_lifting_state_up/labeled_text_field.dart - ein KONTROLLIERTES Widget
// -------------------------------------------------------------------------
// Ein "selbstgebautes" Formularfeld (Label + Feld + Hilfe + Zeichenzähler), das wie ein kontrolliertes Feld
// verwendet wird:
// LabeledTextField(value: _name, onChanged: (v) => setState(() => _name = v), ...)
// Der Wert gehört dem ELTERN-Widget, das ihn übergibt (value) und das
// bei jedem Tastendruck benachrichtigt wird (onChanged). Das Eltern-Widget entscheidet.
//
// Eine Schwierigkeit, die es nur bei Flutter gibt: Ein TextField hält seinen Text in einem
// Controller, der die Neubauten überleben muss. Das Widget hat daher einen
// Zustand (den Controller) ... den es AKTUELL halten muss, wenn das Eltern-Widget
// den Wert ändert (Schaltfläche "Löschen"): Das ist die Aufgabe von didUpdateWidget.
// =========================================================================
import 'package:flutter/material.dart';
class LabeledTextField extends StatefulWidget {
final String value;
final ValueChanged<String> onChanged;
final String label;
final int max;
final String help;
const LabeledTextField({
super.key,
required this.value,
required this.onChanged,
required this.label,
required this.max,
this.help = '',
});
@override
State<LabeledTextField> createState() => _LabeledTextFieldState();
}
class _LabeledTextFieldState extends State<LabeledTextField> {
// late: Das Feld wird später initialisiert (in initState), vor jeder Verwendung
late final TextEditingController _controller;
@override
void initState() {
super.initState();
_controller = TextEditingController(text: widget.value);
}
// aufgerufen, wenn das ELTERN-Widget dieses Widget mit neuen Parametern neu baut;
// oldWidget: das vorherige Widget, zum Vergleichen
@override
void didUpdateWidget(LabeledTextField oldWidget) {
super.didUpdateWidget(oldWidget);
if (widget.value != _controller.text) {
_controller.text = widget.value; // das Eltern-Widget hat den Wert selbst geändert
}
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
final full = widget.value.length == widget.max;
return TextField(
controller: _controller,
maxLength: widget.max, // das Feld lehnt überzählige Zeichen ab
decoration: InputDecoration(
labelText: widget.label,
helperText: widget.help,
// der Rand wird rot, wenn das Feld voll ist
errorText: full ? 'Maximum length reached' : null,
),
onChanged: widget.onChanged, // die Funktion des Eltern-Widgets, unverändert durchgereicht
);
}
}
|
Ein „benutzerdefiniertes“ Formularfeld (Beschriftung + Feld + Tooltip + Zeichenzähler), das als kontrolliertes Feld funktioniert: Der Wert gehört dem Eltern-Widget, das ihn an das Feld übergibt ([value]) und bei jedem Tastendruck benachrichtigt wird ([onChanged]).
- Zeile 40: [late]: Dieses Feld wird später initialisiert (in [initState]), jedoch vor seiner Verwendung. [Dart] prüft dies zur Laufzeit;
- Zeilen 43–45: Der Controller startet mit dem Wert des Eltern-Widgets;
- Zeilen 51–54: Das ist die besondere Herausforderung bei [Flutter]: Ein [TextField] speichert seinen Text in einem Controller, der Neuaufbauten der Seite überstehen muss. Das Widget hat also einen Zustand (den Controller) ... den es aktuell halten muss, wenn das Eltern-Widget den Wert selbst ändert (Schaltfläche „Löschen“). [didUpdateWidget] wird jedes Mal aufgerufen, wenn das Eltern-Widget dieses Widget mit neuen Parametern neu aufbaut; es erhält zum Vergleich das alte Widget. Weicht der Wert des Eltern-Widgets vom Text des Feldes ab, wird er übernommen;
- Zeile 69: Das Feld lehnt überschüssige Zeichen ab und zeigt einen Zähler an („12/20“);
- Zeile 72: Unterhalb des Feldes erscheint ein Tooltip;
- Zeile 74: Der Rand wird rot, wenn das Feld voll ist;
- Zeile 76: die Funktion des Eltern-Widgets, unverändert an [TextField] weitergegeben.
| // =========================================================================
// lib/ex11_lifting_state_up/main.dart - das Eltern-Widget hört auf seine Kinder
// -------------------------------------------------------------------------
// Die Daten fließen nach unten (Parameter); die Information fließt über
// als Parameter übergebene Funktionen nach oben:
// 1. "Ereignisse" des Kindes: onIncrement, onLimit;
// 2. ein kontrolliertes Widget: value + onChanged, wie bei einer Checkbox. Der Zustand
// bleibt Eigentum des Eltern-Widgets, das ihn selbst ändern kann (Clear).
// =========================================================================
import 'package:flutter/material.dart';
import 'labeled_text_field.dart';
import 'counter.dart';
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const ParentPage(),
),
);
}
class ParentPage extends StatefulWidget {
const ParentPage({super.key});
@override
State<ParentPage> createState() => _ParentPageState();
}
class _ParentPageState extends State<ParentPage> {
int _total = 0;
String _message = '';
String _firstName = 'Marie';
String _lastName = 'PELISSIER';
// die von einem Zähler aufgerufene Funktion: Sie erhält den Wert, den der Zähler übergibt
void _onIncrement(String label, int value) {
setState(() {
_total++;
_message = '$label is now $value';
});
}
void _clear() {
setState(() {
_firstName = '';
_lastName = '';
});
}
@override
Widget build(BuildContext context) {
final titleStyle = Theme.of(context).textTheme.titleSmall;
return Scaffold(
appBar: AppBar(title: const Text('Example 11 - the child notifies its parent')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('1. Functions called by the children', style: titleStyle),
Counter(
label: 'Coffees',
max: 3,
onIncrement: (v) => _onIncrement('Coffees', v),
onLimit: () => setState(() => _message = 'No more than 3 coffees!'),
),
Counter(
label: 'Glasses of water',
max: 8,
onIncrement: (v) => _onIncrement('Glasses of water', v),
onLimit: () => setState(() => _message = 'Enough drinking.'),
),
const SizedBox(height: 8),
Text('Total of the clicks: $_total - $_message', style: const TextStyle(fontStyle: FontStyle.italic)),
],
),
),
),
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('2. Controlled widgets', style: titleStyle),
LabeledTextField(
value: _firstName,
onChanged: (v) => setState(() => _firstName = v),
label: 'First name',
max: 20,
help: 'Required',
),
LabeledTextField(
value: _lastName,
onChanged: (v) => setState(() => _lastName = v),
label: 'Last name',
max: 20,
help: 'Upper-cased when displayed',
),
const SizedBox(height: 8),
Text.rich(
TextSpan(
children: [
const TextSpan(text: "Parent's data: "),
TextSpan(
text: '$_firstName ${_lastName.toUpperCase()}',
style: const TextStyle(fontWeight: FontWeight.bold),
),
],
),
),
const SizedBox(height: 8),
OutlinedButton(onPressed: _clear, child: const Text('Clear (from the parent)')),
],
),
),
),
],
),
);
}
}
|
- Zeilen 40–43: die von einem Zähler aufgerufene Funktion; sie erhält den vom Zähler übergebenen Wert;
- Zeilen 69–73: ein Zähler und die Funktionen, die er aufrufen wird. [(v) => _onIncrement('Coffees', v)]: eine anonyme Funktion, die ihr eigenes Argument (die Beschriftung) hinzufügt;
- Zeilen 94–99: ein kontrolliertes Feld: sein Wert und die Funktion, die den Zustand des Eltern-Widgets ändert;
- Zeile 114: die Daten des Eltern-Widgets, die der Eingabe folgen;
- Zeile 121: Das Eltern-Widget ändert den Wert selbst: Die Felder werden geleert (über ihr [didUpdateWidget]).
Drücken Sie viermal auf den ersten Zähler, einmal auf den zweiten und geben Sie den Namen ein; leeren Sie dann die Felder vom Eltern-Widget aus:
4.3. Beispiel 12: Komposition
4.3.1. Eine Karte
Die Parameter eines Widgets übermitteln Daten ... aber auch Inhalt: Ein Widget ist ein Wert wie jeder andere und kann an ein anderes Widget übergeben werden. [Flutter] nutzt dies überall: das [child] eines [Padding], den [title] einer [AppBar], den [body] eines [Scaffold].
| // =========================================================================
// lib/ex12_composition/info_card.dart - ein wiederverwendbares TEMPLATE
// -------------------------------------------------------------------------
// Die Parameter eines Widgets übergeben DATEN ... aber auch
// INHALT: Ein Widget ist ein Wert wie jeder andere, der an
// ein anderes Widget übergeben werden kann, das ihn platziert, wo es will. Flutter nutzt das überall:
// das Kind eines Padding, der Titel einer AppBar, der Body eines Scaffold ...
// - child: per Konvention der "Haupt"-Inhalt;
// - header, footer: andere Stellen (einige "Slots"), vom
// Eltern-Widget bereitgestellt; der Header hat einen Standardinhalt, der Footer ist optional.
// Die Karte legt den Rahmen fest (Rand, Header, Footer), das Eltern-Widget liefert, was
// hineinkommt.
// =========================================================================
import 'package:flutter/material.dart';
class InfoCard extends StatelessWidget {
final Color? color; // "?": optional (standardmäßig null)
final Widget header;
final Widget? footer;
final Widget child;
const InfoCard({super.key, this.color, this.header = const Text('Untitled'), this.footer, required this.child});
@override
Widget build(BuildContext context) {
final background = color ?? Colors.grey.shade300;
return Card(
// clipBehavior: Der farbige Header folgt den abgerundeten Ecken der Karte
clipBehavior: Clip.antiAlias,
shape: RoundedRectangleBorder(
borderRadius: BorderRadius.circular(8),
side: BorderSide(color: background),
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Container(
color: background,
padding: const EdgeInsets.all(10),
// DefaultTextStyle: der Stil ALLER Texte des Headers,
// gleichgültig, welches Widget das Eltern-Widget liefert
child: DefaultTextStyle.merge(
style: TextStyle(color: color == null ? Colors.black : Colors.white, fontWeight: FontWeight.bold),
child: header,
),
),
Padding(padding: const EdgeInsets.all(10), child: child),
// kein Footer angegeben: überhaupt kein Footer
if (footer != null)
Container(
color: Colors.grey.shade100,
padding: const EdgeInsets.all(8),
child: DefaultTextStyle.merge(
style: const TextStyle(color: Colors.grey, fontSize: 12),
child: footer!,
),
),
],
),
);
}
}
|
- Zeilen 18–21: Parameter: eine optionale Farbe ([Color?]) und drei Slots für Inhalt: [header], [footer] (optional) und [child], den Hauptinhalt;
- Zeile 23: Der Header hat einen Standardinhalt: ein konstantes Widget;
- Zeile 27: die Farbe des Headers: die angegebene oder Hellgrau;
- Zeile 30: Der farbige Header wird passend zu den abgerundeten Ecken der Karte zugeschnitten;
- Zeilen 43–45: [DefaultTextStyle] legt den Stil ALLES Textes in seinem Teilbaum fest, unabhängig vom Widget, das das Eltern-Widget bereitstellt: Der Header ist fett, weiß auf farbigem Hintergrund;
- Zeile 48: der vom Eltern-Widget bereitgestellte Hauptinhalt;
- Zeilen 50–58: kein Footer angegeben; also gar kein Footer. [footer!]: in diesem Zweig ist [footer] nicht [null] (der Compiler kann dies für ein Feld nicht ableiten, daher das [!]).
4.3.2. Eine generische Tabelle
| // =========================================================================
// lib/ex12_composition/simple_table.dart - eine GENERISCHE Tabelle
// -------------------------------------------------------------------------
// SimpleTable<T> ist ein generisches Widget: Es zeigt Zeilen beliebigen
// Typs T an. Es weiß, wie man die Zeilen durchläuft, aber nicht, wie man EINE
// Zeile anzeigt: Das sagt ihm das Eltern-Widget, indem es ihm eine FUNKTION übergibt,
// cells(row, index), die die Widgets der Zellen zurückgibt.
// Das ist das Prinzip der "Builder" von Flutter (ListView.builder,
// FutureBuilder ...): Der vom Eltern-Widget gelieferte Inhalt verwendet Daten,
// die dem Kind gehören (die Zeile, ihr Rang).
// =========================================================================
import 'package:flutter/material.dart';
// der Typ einer Funktion, die die Zellen einer Zeile baut
typedef CellsBuilder<T> = List<Widget> Function(T row, int index);
class SimpleTable<T> extends StatelessWidget {
final List<T> rows;
final List<String> columns;
final CellsBuilder<T> cells;
final Widget empty; // wird angezeigt, wenn es keine Zeile gibt
const SimpleTable({
super.key,
required this.rows,
required this.columns,
required this.cells,
this.empty = const Text('No data.'),
});
// eine Zelle: ein kleiner Rand um ihren Inhalt
static Widget _cell(Widget content) => Padding(padding: const EdgeInsets.all(6), child: content);
@override
Widget build(BuildContext context) {
if (rows.isEmpty) {
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(columns.join(' '), style: const TextStyle(fontWeight: FontWeight.bold)),
const Divider(),
DefaultTextStyle.merge(
style: const TextStyle(color: Colors.grey),
child: empty,
),
],
);
}
return Table(
defaultVerticalAlignment: TableCellVerticalAlignment.middle,
border: TableBorder(horizontalInside: BorderSide(color: Colors.grey.shade300)),
children: [
TableRow(
children: [for (final c in columns) _cell(Text(c, style: const TextStyle(fontWeight: FontWeight.bold)))],
),
for (final (i, row) in rows.indexed)
// die Zellen DIESER Zeile, von der Funktion des Eltern-Widgets gebaut
TableRow(children: [for (final c in cells(row, i)) _cell(c)]),
],
);
}
}
|
- Zeile 16: der Typ einer Funktion, die eine Zeile (vom Typ [T]) und ihren Index entgegennimmt und die Widgets ihrer Zellen zurückgibt;
- Zeile 18: ein generisches Widget: Es zeigt Zeilen beliebigen Typs an ([T]). Es weiß, wie es die Zeilen durchläuft, aber nicht, wie EINE Zeile dargestellt wird; das Eltern-Widget teilt es ihm mit, indem es ihm die Funktion [cells] übergibt. Das ist das Prinzip hinter den „Buildern“ von [Flutter] ([ListView.builder], [FutureBuilder]...): Der Inhalt stammt vom Eltern-Widget, verwendet aber Daten, die dem Kind gehören (die Zeile, ihren Index). [React] nennt dies eine „Render Prop“;
- Zeile 33: eine [static]-Methode, die keine Felder des Widgets verwendet;
- Zeilen 37–45: keine Zeile: die Spaltenüberschriften und der Inhalt [empty], vom Eltern-Widget bereitgestellt;
- Zeilen 50–59: die Tabelle: eine Kopfzeile, gefolgt von einer Zeile pro Eintrag, deren Zellen von der Funktion des Eltern-Widgets erzeugt werden.
| // =========================================================================
// lib/ex12_composition/main.dart - die Templates InfoCard und SimpleTable verwenden
// =========================================================================
import 'package:flutter/material.dart';
import 'info_card.dart';
import 'simple_table.dart';
// ein Slot: ein benannter Record (keine Klasse nötig)
typedef Slot = ({int id, String timeRange, String? patient});
const slots = <Slot>[
(id: 1, timeRange: '8:00 - 8:20', patient: null),
(id: 2, timeRange: '8:20 - 8:40', patient: 'Mme Alice DURAND'),
(id: 3, timeRange: '8:40 - 9:00', patient: null),
];
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const CompositionPage(),
),
);
}
class CompositionPage extends StatelessWidget {
const CompositionPage({super.key});
@override
Widget build(BuildContext context) {
final free = slots.where((c) => c.patient == null).length;
return Scaffold(
appBar: AppBar(title: const Text('Example 12 - the composition')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
// header und footer: als Parameter übergebene Widgets; child: der Inhalt
InfoCard(
color: Colors.indigo,
header: const Row(
children: [
Icon(Icons.event, color: Colors.white),
SizedBox(width: 8),
// Expanded: Der Text nimmt den verbleibenden Platz ein (und bricht um)
Expanded(child: Text('Schedule of Mme PELISSIER')),
],
),
footer: Text('$free free slot(s)'),
// SimpleTable<Slot>: T wird aus dem Typ der Zeilen abgeleitet
child: SimpleTable(
rows: slots,
columns: const ['#', 'Slot', 'Status'],
// die Funktion, die die Zellen EINER Zeile baut;
// c erhält die Zeile, i ihren Rang
cells: (c, i) => [
Text('${i + 1}'),
Text(c.timeRange),
c.patient != null
? Chip(label: Text(c.patient!), visualDensity: VisualDensity.compact)
: Chip(
label: const Text('Free'),
backgroundColor: Colors.green.shade100,
visualDensity: VisualDensity.compact,
),
],
),
),
const InfoCard(
color: Colors.green,
header: Text('A card without a footer'),
child: Text('The footer is not provided: the card does not display it.'),
),
// kein Header angegeben: der Standardinhalt, "Untitled"
InfoCard(
child: SimpleTable<({int id, String name})>(
rows: const [],
columns: const ['Name'],
cells: (p, _) => [Text(p.name)],
empty: const Text('Nobody for now.'),
),
),
],
),
);
}
}
|
- Zeile 11: ein Slot in Form eines benannten Records;
- Zeilen 42–52: eine Karte: ihre Farbe, ein Header (eine Zeile: ein Symbol und Text), ein Footer;
- Zeilen 54–66: ihr Inhalt: eine Tabelle von Slots. [T] wird vom Typ von [rows] abgeleitet: Es ist ein [SimpleTable<Slot>]. Die Funktion [cells] nimmt ein Zeitfenster ([c]) und seinen Rang ([i]) entgegen und gibt drei Widgets zurück;
- Zeilen 72–75: eine Karte ohne Footer;
- Zeilen 79–83: eine Karte ohne Header (der Standardinhalt, „Untitled“); ihre Tabelle ist leer. [SimpleTable<({int id, String name})>]: Der Typ [T] wird explizit angegeben, weil [rows: const []] seine Ableitung nicht zulässt.

Die Karte legt den Rahmen fest (Rand, Header, Footer); das Eltern-Widget liefert den Inhalt darin. So sind auch die Widgets von [Flutter] selbst aufgebaut: [Scaffold] legt die Struktur eines Bildschirms fest und erhält die obere Leiste, den Hauptteil und die schwebende Schaltfläche.
4.4.1. Eine Uhr
| // =========================================================================
// lib/ex13_lifecycle/clock.dart - ein Widget, das startet und stoppt
// -------------------------------------------------------------------------
// Das Leben des State-Objekts eines StatefulWidget:
// 1. initState() : Es wurde gerade erzeugt, das Widget erscheint gleich.
// Was gestartet werden muss, wird dort gestartet;
// 2. didChangeDependencies() : direkt danach, dann jedes Mal, wenn sich ein geerbtes
// Datum ändert, das es liest (siehe Beispiel 14);
// 3. build() : so oft wie nötig;
// 4. didUpdateWidget(old) : Das Eltern-Widget hat es mit neuen
// Parametern neu gebaut;
// 5. dispose() : Das Widget verschwindet endgültig. Was
// gestartet wurde, wird dort GESTOPPT.
// Eine Uhr startet einen Timer (Timer.periodic), wenn sie erscheint ...
// und muss ihn unbedingt stoppen, wenn sie verschwindet: Andernfalls
// würde der Timer umsonst weiterlaufen und setState()
// auf einem toten Objekt aufrufen (ein Fehler).
// =========================================================================
import 'dart:async';
import 'package:flutter/material.dart';
String currentTime() => DateTime.now().toString().substring(11, 19); // "12:05:09"
class Clock extends StatefulWidget {
final ValueChanged<String> onLog;
final Color color;
const Clock({super.key, required this.onLog, this.color = Colors.indigo});
@override
State<Clock> createState() => _ClockState();
}
class _ClockState extends State<Clock> {
String _time = currentTime();
// late: in initState initialisiert
late final Timer _timer;
// das Eltern-Widget benachrichtigen ... NACH dem Aufbau des aktuellen Bildschirms: Wir
// ändern den Zustand eines Widgets (des Eltern-Widgets) nicht, während es gebaut wird
void _log(String message) {
WidgetsBinding.instance.addPostFrameCallback((_) => widget.onLog(message));
}
@override
void initState() {
super.initState(); // immer zuerst
_log('Clock: initState - starting the timer');
_timer = Timer.periodic(const Duration(seconds: 1), (_) {
setState(() => _time = currentTime());
});
}
@override
void didUpdateWidget(Clock oldWidget) {
super.didUpdateWidget(oldWidget);
if (oldWidget.color != widget.color) {
_log('Clock: didUpdateWidget - new color');
}
}
@override
void dispose() {
_timer.cancel(); // das AUFRÄUMEN
_log('Clock: dispose - timer stopped');
super.dispose(); // immer zuletzt
}
@override
Widget build(BuildContext context) {
return Text(
_time,
style: TextStyle(fontSize: 40, fontFamily: 'RobotoMono', color: widget.color),
);
}
}
|
Der Lebenszyklus des [State]-Objekts innerhalb eines [StatefulWidget]:
Methode | Wann? |
initState() | Das Objekt wurde gerade erzeugt; das Widget wird erscheinen. Hier starten Sie alles, was gestartet werden muss (Timer, Abonnement usw.) |
didChangeDependencies() | Unmittelbar nach initState, danach immer dann, wenn sich von ihm gelesene vererbte Daten ändern (siehe Beispiel 14) |
build() | so oft wie nötig |
didUpdateWidget(old) | Das Eltern-Widget hat es mit neuen Parametern neu aufgebaut |
dispose() | Das Widget verschwindet endgültig. Alles, was dort gestartet wurde, wird gestoppt |
- Zeilen 37–39: der Zustand: die angezeigte Uhrzeit und ein Timer ([Timer], aus der Bibliothek [dart:async]);
- Zeilen 43–44: Die Uhr benachrichtigt ihr Eltern-Widget über jede Phase ihres Lebenszyklus. Sie tut dies aber während [initState] oder [dispose] – also während [Flutter] den Bildschirm aufbaut: Das Eltern-Widget kann seinen Zustand in diesem Moment nicht ändern ([setState] würde einen Fehler verursachen). [addPostFrameCallback] verschiebt den Aufruf, bis das aktuelle Bild fertig gezeichnet ist;
- Zeilen 48–52: [super.initState()] zuerst, immer. Dann wird ein periodischer Timer gestartet: Seine Funktion wird jede Sekunde aufgerufen und aktualisiert die Uhrzeit;
- Zeilen 57–60: Das Eltern-Widget hat die Uhr in einer anderen Farbe neu gezeichnet: Das wird vermerkt;
- Zeilen 65–68: Aufräumen: Wir stoppen den Timer. Andernfalls würde er unnötig weiterlaufen und [setState] auf einem toten Objekt aufrufen, was zu einem Fehler („setState() called after dispose()“) und einem Speicherleck führt. [super.dispose()] steht immer an letzter Stelle.
| // =========================================================================
// lib/ex13_lifecycle/main.dart
// -------------------------------------------------------------------------
// - if (_withClock) Clock(...): Das Anhaken / Abwählen des Kästchens lässt
// das Widget erscheinen / verschwinden (initState, dann dispose, siehe
// clock.dart); eine Änderung seiner Farbe baut es neu (didUpdateWidget);
// - autofocus: ein Eingabefeld, das den Fokus übernimmt, sobald es erscheint
// (die Tastatur des Telefons öffnet sich);
// - der Titel der Anwendung folgt der Eingabe (Widget Title);
// - AppLifecycleListener: das Leben der ANWENDUNG selbst. Auf einem
// Telefon geht sie in den Hintergrund (eine andere Anwendung wird geöffnet,
// der Bildschirm schaltet sich aus) und kommt dann zurück: Wir können darauf reagieren (speichern,
// einen Timer stoppen ...).
// =========================================================================
import 'package:flutter/material.dart';
import 'clock.dart';
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const LifecyclePage(),
),
);
}
class LifecyclePage extends StatefulWidget {
const LifecyclePage({super.key});
@override
State<LifecyclePage> createState() => _LifecyclePageState();
}
class _LifecyclePageState extends State<LifecyclePage> {
bool _withClock = true;
bool _red = false;
final List<String> _log = [];
String _search = '';
bool _showSearch = false;
late final AppLifecycleListener _listener;
void _trace(String message) {
// die Uhr kann benachrichtigen, NACHDEM der Bildschirm verschwunden ist (Schließen der Anwendung)
if (!mounted) return;
setState(() => _log.add('${currentTime()} $message'));
}
@override
void initState() {
super.initState();
// die Anwendung wechselt den Zustand: resumed (im Vordergrund), inactive,
// hidden, paused (im Hintergrund) ...
_listener = AppLifecycleListener(onStateChange: (state) => _trace('Application: ${state.name}'));
}
@override
void dispose() {
_listener.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return Title(
title: _search.isEmpty ? 'Example 13' : 'Search: $_search',
color: Colors.indigo,
child: Scaffold(
appBar: AppBar(title: const Text('Example 13 - the lifecycle')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
CheckboxListTile(
contentPadding: EdgeInsets.zero,
controlAffinity: ListTileControlAffinity.leading,
title: const Text('show the clock'),
value: _withClock,
onChanged: (v) => setState(() => _withClock = v!),
),
CheckboxListTile(
contentPadding: EdgeInsets.zero,
controlAffinity: ListTileControlAffinity.leading,
title: const Text('in red'),
value: _red,
onChanged: (v) => setState(() => _red = v!),
),
if (_withClock) Clock(onLog: _trace, color: _red ? Colors.red : Colors.indigo),
],
),
),
),
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: !_showSearch
? Align(
alignment: Alignment.centerLeft,
child: OutlinedButton(
onPressed: () => setState(() => _showSearch = true),
child: const Text('Search...'),
),
)
// autofocus: der Fokus, sobald das Feld erscheint
: TextField(
autofocus: true,
decoration: const InputDecoration(hintText: 'the title follows the input'),
onChanged: (v) => setState(() => _search = v),
),
),
),
Text('Log', style: Theme.of(context).textTheme.titleSmall),
for (final (i, line) in _log.indexed) Text('${i + 1}. $line', style: const TextStyle(fontSize: 12)),
],
),
),
);
}
}
|
- Zeilen 56–61: das Leben der Anwendung selbst. Auf einem Smartphone wechselt sie in den Hintergrund (Sie öffnen eine andere App, der Bildschirm schaltet sich aus) und kehrt dann zurück: [AppLifecycleListener] meldet jede Änderung ([resumed]: im Vordergrund; [inactive], [hidden], [paused]: Wechsel in den Hintergrund ...). Auf diese Meldungen würden Sie reagieren, um einen Entwurf zu speichern oder einen Timer zu stoppen. Der Listener wird in [initState] erzeugt und in [dispose] freigegeben: dasselbe Muster wie beim Timer der Uhr;
- Zeile 95: Durch Ankreuzen des Kontrollkästchens wird die Uhr angezeigt ([initState]); durch Abwählen wird sie ausgeblendet ([dispose]); eine Änderung ihrer Farbe zeichnet sie neu ([didUpdateWidget]);
- Zeilen 112–115: ein Feld, das erst nach dem Antippen von „Search...“ erscheint. [autofocus: true]: Es erhält den Fokus, sobald es erscheint, und die Tastatur des Smartphones öffnet sich;
- Zeile 68: Der Titel der App wird während der Eingabe aktualisiert.
Wir ändern die Farbe, entfernen die Uhr und fügen sie wieder hinzu, öffnen die Suche und tippen einen Namen:

Das Protokoll zeigt die Aktivität der Uhr: Start, Farbwechsel, Stopp, Start.
Teilnehmer des Kurses zu [React] werden dies mit [useEffect] vergleichen: Was [React] in einem Effekt und seiner Aufräumfunktion schreibt, verteilt [Flutter] auf [initState] und [dispose]; was [React] aus dem Abhängigkeits-Array eines Effekts erhält, erhält [Flutter] mithilfe von [didUpdateWidget], indem das alte Widget mit dem neuen verglichen wird.
4.5. Beispiel 14: Vererbte Daten
Wie können Sie Daten und Funktionen zwischen weit voneinander entfernten Widgets teilen, ohne sie über alle Zwischenstationen von Parameter zu Parameter weiterzureichen? Mit vererbten Daten, etwa über [InheritedWidget]. Dies ist der Mechanismus, den [Flutter] selbst verwendet: [Theme.of(context)], [MediaQuery.of(context)], [Navigator.of(context)] ... sind Lesezugriffe auf vererbte Daten. [React] nennt dies einen Context; [Angular] würde von einem Service sprechen.
4.5.1. Ein Datensatz für die gesamte Anwendung
| // =========================================================================
// lib/ex14_inherited_data/providers/log.dart - ein Datum für die GESAMTE Anwendung
// -------------------------------------------------------------------------
// Wie lassen sich Daten und Funktionen zwischen entfernten
// Widgets teilen, ohne sie von Parameter zu Parameter durch alle
// Zwischenstationen zu reichen? Mit einem InheritedWidget, einem "geerbten" Datum:
// 1. Ein PROVIDER-Widget, hoch im Baum platziert, trägt die Daten;
// 2. jeder Nachfahre, in beliebiger Tiefe, LIEST sie
// mit context.dependOnInheritedWidgetOfExactType<Provider>();
// 3. der Nachfahre, der sie gelesen hat, ist dann ABONNIERT: Er wird neu gebaut,
// wenn sich die Daten ändern.
// Es ist der Mechanismus, den Flutter selbst verwendet: Theme.of(context),
// MediaQuery.of(context), Navigator.of(context) ... sind Lesezugriffe auf
// geerbte Daten.
//
// InheritedNotifier ist eine vorgefertigte Variante: Das Datum ist ein Objekt, das
// seine Änderungen MELDET (ein ChangeNotifier, der
// notifyListeners() aufruft), und der Provider baut dann seine Leser neu.
// Die Konvention: eine statische Methode of(context), um die Daten zu lesen.
// =========================================================================
import 'package:flutter/material.dart';
// die Daten: ein ChangeNotifier. notifyListeners() benachrichtigt seine Abonnenten
class Log extends ChangeNotifier {
final List<String> lines = [];
void trace(String message) {
lines.insert(0, '${DateTime.now().toString().substring(11, 19)} $message');
if (lines.length > 6) lines.removeLast();
notifyListeners();
}
}
// der Provider: Er trägt das Log und baut seine Leser neu, wenn
// das Log eine Änderung meldet
class LogProvider extends InheritedNotifier<Log> {
const LogProvider({super.key, required Log log, required super.child}) : super(notifier: log);
// das Lesen: der NÄCHSTE Provider oberhalb von context
static Log of(BuildContext context) {
final provider = context.dependOnInheritedWidgetOfExactType<LogProvider>();
if (provider == null) {
throw FlutterError('LogProvider.of: no LogProvider above this widget');
}
return provider.notifier!;
}
}
|
- Zeilen 25–31: die gemeinsamen Daten: ein Protokoll. Es ist ein [ChangeNotifier], ein Objekt, das seine Listener über Änderungen benachrichtigt: Jede Methode, die es ändert, ruft [notifyListeners()] auf;
- Zeilen 37–38: der Provider: ein Widget weit oben im Baum, das das Protokoll hält. [InheritedNotifier] ist ein [InheritedWidget] , das für einen [ChangeNotifier] vorbereitet ist: Meldet das Protokoll eine Änderung, baut der Provider alle Widgets neu auf, die es gelesen haben;
- Zeilen 41–46: Lesen über eine statische Methode [of(context)], wie sie von [Flutter] verwendet wird. [context.dependOnInheritedWidgetOfExactType<LogProvider>()] durchläuft den Baum von [context] aus nach oben bis zum nächsten Provider und abonniert das Widget, das die Daten liest: Es wird neu aufgebaut, wenn sich die Daten ändern. Gibt es darüber keinen Provider, handelt es sich um einen Programmierfehler: Er wird deutlich gemeldet.
| // =========================================================================
// lib/ex14_inherited_data/providers/cart.dart - ein Datum, das von EINEM Widget bereitgestellt wird
// -------------------------------------------------------------------------
// Der Warenkorb wird nur einem Teil des Baums bereitgestellt: den Widgets,
// die CartProvider umschließt (siehe main.dart). Zwei Provider an
// zwei Stellen des Bildschirms würden zwei unabhängige Warenkörbe ergeben.
// Der Provider ist hier ein StatefulWidget: Er ERZEUGT den Warenkorb
// (didChangeDependencies) und gibt ihn frei (dispose). Er verwendet das Log selbst.
// =========================================================================
import 'package:flutter/material.dart';
import 'log.dart';
typedef Item = ({String label, double price});
class Cart extends ChangeNotifier {
final Log _log;
final List<Item> items = [];
Cart(this._log);
// ein berechneter Wert: fold "faltet" die Liste zu einem einzigen Wert
double get total => items.fold(0, (sum, a) => sum + a.price);
void add(Item item) {
items.add(item);
_log.trace('cart: + ${item.label}');
notifyListeners();
}
void remove(int index) {
_log.trace('cart: - ${items[index].label}');
items.removeAt(index);
notifyListeners();
}
}
class CartProvider extends StatefulWidget {
final Widget child;
const CartProvider({super.key, required this.child});
// das Lesen über das private Widget _InheritedCart, das in build() platziert wird
static Cart of(BuildContext context) {
final inherited = context.dependOnInheritedWidgetOfExactType<_InheritedCart>();
if (inherited == null) {
throw FlutterError('CartProvider.of: no CartProvider above this widget');
}
return inherited.notifier!;
}
@override
State<CartProvider> createState() => _CartProviderState();
}
class _CartProviderState extends State<CartProvider> {
Cart? _cart; // null, solange er nicht erzeugt ist
// direkt nach initState aufgerufen: Das Widget kann dann die geerbten
// Daten LESEN. getInheritedWidgetOfExactType: das Log lesen, OHNE seine
// Änderungen zu abonnieren (der Provider des Warenkorbs muss nicht neu gebaut werden,
// sooft sich das Log ändert)
@override
void didChangeDependencies() {
super.didChangeDependencies();
// ??=: Der Warenkorb wird nur beim ersten Mal erzeugt
_cart ??= Cart(context.getInheritedWidgetOfExactType<LogProvider>()!.notifier!);
}
@override
void dispose() {
_cart?.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) => _InheritedCart(notifier: _cart!, child: widget.child);
}
class _InheritedCart extends InheritedNotifier<Cart> {
const _InheritedCart({required super.notifier, required super.child});
}
|
- Zeilen 17–24: der Warenkorb, ein weiterer [ChangeNotifier]. Er erhält bei seiner Erzeugung das Protokoll, um jedes Hinzufügen und Entfernen festzuhalten. [fold] „faltet“ die Liste zu einem einzigen Wert zusammen: der Summe der Preise;
- Zeilen 39–40: Diesmal ist der Provider ein [StatefulWidget]: Er ist es, der den Warenkorb erzeugt und freigibt. Er wird nur den Widgets bereitgestellt, die er umschließt ([child]);
- Zeilen 45–50: das private Widget [_InheritedCart], das der Provider über seinem Kind platziert, liest die Daten;
- Zeilen 65–68: Der Warenkorb wird in [didChangeDependencies] erzeugt, das unmittelbar nach [initState] aufgerufen wird und von dem aus ein Widget die vererbten Daten lesen kann. [??=]: Er wird nur beim ersten Mal erzeugt. [getInheritedWidgetOfExactType] liest das Protokoll, OHNE seine Änderungen zu abonnieren: Der Provider des Warenkorbs muss nicht jedes Mal neu aufgebaut werden, wenn sich das Protokoll ändert;
- Zeile 78: Der Provider platziert die vererbten Daten über seinem Kind;
- Zeilen 81–82: die vererbten Daten selbst, die privat sind.
4.5.3. Ein konfigurierter Provider
| // =========================================================================
// lib/ex14_inherited_data/providers/clock.dart - ein PARAMETRISIERTER Provider
// -------------------------------------------------------------------------
// Eine Uhr, deren Aktualisierungsintervall ein Parameter des
// Providers ist: ClockProvider(period: Duration(seconds: 5), ...).
// Zwei verschachtelte Provider: Ein Widget liest den, der ihm am NÄCHSTEN
// ist. Diesmal schreiben wir ein InheritedWidget "von Hand": Es ist
// updateShouldNotify, das angibt, ob die Leser neu gebaut werden müssen.
// Die Uhr stoppt, wenn ihr Provider verschwindet (dispose).
// =========================================================================
import 'dart:async';
import 'package:flutter/material.dart';
class ClockProvider extends StatefulWidget {
final Duration period;
final Widget child;
const ClockProvider({super.key, this.period = const Duration(seconds: 1), required this.child});
// der Standardwert: ein eingefrorenes Datum, von einem Widget ohne Provider gelesen
static DateTime of(BuildContext context) =>
context.dependOnInheritedWidgetOfExactType<_InheritedClock>()?.now ?? DateTime(2026);
@override
State<ClockProvider> createState() => _ClockProviderState();
}
class _ClockProviderState extends State<ClockProvider> {
DateTime _now = DateTime.now();
Timer? _timer;
void _start() {
_timer?.cancel();
_timer = Timer.periodic(widget.period, (_) => setState(() => _now = DateTime.now()));
}
@override
void initState() {
super.initState();
_start();
}
// Wenn das Eltern-Widget das Intervall ändert, wird der Timer neu gestartet
@override
void didUpdateWidget(ClockProvider oldWidget) {
super.didUpdateWidget(oldWidget);
if (oldWidget.period != widget.period) _start();
}
@override
void dispose() {
_timer?.cancel();
super.dispose();
}
@override
Widget build(BuildContext context) => _InheritedClock(now: _now, child: widget.child);
}
class _InheritedClock extends InheritedWidget {
final DateTime now;
const _InheritedClock({required this.now, required super.child});
// aufgerufen, wenn der Provider neu gebaut wird: Müssen die Leser
// neu gebaut werden? Ja, wenn sich die Zeit geändert hat
@override
bool updateShouldNotify(_InheritedClock oldWidget) => oldWidget.now != now;
}
|
- Zeile 23: der Lesezugriff; ohne Provider ein Standardwert (ein festes Datum). [?.]: Wird kein Provider gefunden, ist das Ergebnis [null], und [??] übernimmt dann den Standardwert;
- Zeilen 34–36: ein Timer, dessen Periode als Parameter angegeben wird;
- Zeilen 47–49: Ändert das Eltern-Widget die Periode, wird der Timer neu gestartet;
- Zeilen 62–70: Diesmal ein „von Hand“ geschriebenes [InheritedWidget] . Es trägt ein Datum (die Uhrzeit). Bei jedem Neuaufbau des Providers (jede Sekunde) [Flutter] ruft [updateShouldNotify] mit dem alten Widget auf: Gibt es [true] zurück, werden die Widgets neu aufgebaut, die die Daten lesen.
| // lib/ex14_inherited_data/catalog.dart - ein Nachfahre, der dem Warenkorb etwas HINZUFÜGT
import 'package:flutter/material.dart';
import 'providers/cart.dart';
const catalog = <Item>[
(label: 'Consultation', price: 30),
(label: 'Vaccine', price: 12.5),
(label: 'Certificate', price: 5),
];
class Catalog extends StatelessWidget {
const Catalog({super.key});
@override
Widget build(BuildContext context) {
// der von ShopPage bereitgestellte Warenkorb (ein Fehler, wenn ihn niemand bereitstellt)
final cart = CartProvider.of(context);
return Card(
child: Column(
children: [
for (final a in catalog)
ListTile(
dense: true,
title: Text('${a.label} (${a.price} €)'),
trailing: IconButton(icon: const Icon(Icons.add_shopping_cart), onPressed: () => cart.add(a)),
),
],
),
);
}
}
|
- Zeile 18: Der Katalog liest den oben bereitgestellten Warenkorb und fügt ihm Artikel hinzu.
| // =========================================================================
// lib/ex14_inherited_data/cart_summary.dart
// -------------------------------------------------------------------------
// Ein weiterer Nachfahre: DERSELBE Warenkorb wie bei Catalog, aber SEINE EIGENE
// Uhr, alle 5 Sekunden aktualisiert. Ein Widget liest nur die
// Provider, die OBERHALB von ihm liegen: CartSummary setzt daher einen zweiten
// ClockProvider um seinen Inhalt, den es an ein kleines
// Widget übergibt, _Content (dessen Kontext selbst UNTERHALB dieses Providers liegt).
// =========================================================================
import 'package:flutter/material.dart';
import 'providers/clock.dart';
import 'providers/cart.dart';
class CartSummary extends StatelessWidget {
const CartSummary({super.key});
@override
Widget build(BuildContext context) {
return const ClockProvider(period: Duration(seconds: 5), child: _Content());
}
}
class _Content extends StatelessWidget {
const _Content();
@override
Widget build(BuildContext context) {
final cart = CartProvider.of(context);
final now = ClockProvider.of(context); // der nächste: der 5-s-Provider
return Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'Cart (${cart.items.length} item(s)) - ${now.toString().substring(11, 19)}',
style: Theme.of(context).textTheme.titleSmall,
),
for (final (i, a) in cart.items.indexed)
Row(
children: [
Text(a.label),
TextButton(onPressed: () => cart.remove(i), child: const Text('remove')),
],
),
Text('Total: ${cart.total} €', style: const TextStyle(fontWeight: FontWeight.bold)),
],
),
),
);
}
}
|
- Zeile 21: Die Zusammenfassung platziert einen zweiten Uhr-Provider mit einer Periode von 5 Sekunden um ihren Inhalt. Ein Widget liest nur die Provider, die über ihm liegen: Deshalb ist der Inhalt ein eigenständiges Widget, [_Content], dessen [context] UNTERHALB dieses Providers liegt (der [context] von [CartSummary]liegt dagegen darüber);
- Zeilen 30–31: Es liest DENSELBEN Warenkorb wie der Katalog, aber die nächstgelegene Uhr ist die mit 5 Sekunden.
| // =========================================================================
// lib/ex14_inherited_data/main.dart - drei Ebenen geerbter Daten
// -------------------------------------------------------------------------
// - das Log: ganz oben bereitgestellt (oberhalb von MaterialApp), für die gesamte
// Anwendung;
// - der Warenkorb, von ShopPage bereitgestellt: von Catalog und
// CartSummary geteilt, die DENSELBEN Warenkorb sehen;
// - die Uhr, von ShopPage (Standardintervall, 1 s) UND von
// CartSummary (5 s) bereitgestellt: jeweils eine eigene.
// =========================================================================
import 'package:flutter/material.dart';
import 'catalog.dart';
import 'providers/clock.dart';
import 'providers/log.dart';
import 'providers/cart.dart';
import 'cart_summary.dart';
void main() {
runApp(
LogProvider(
log: Log(),
child: MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const ShopPage(),
),
),
);
}
// die Zeit der Uhr der Seite: ein kleines Widget, UNTERHALB des Providers platziert
class _PageTime extends StatelessWidget {
const _PageTime();
@override
Widget build(BuildContext context) {
final time = ClockProvider.of(context).toString().substring(11, 19);
return Text('Clock of the page: $time', style: const TextStyle(color: Colors.grey));
}
}
class ShopPage extends StatelessWidget {
const ShopPage({super.key});
@override
Widget build(BuildContext context) {
// Die Seite liest das Log: Sie wird bei jeder neuen Zeile neu gebaut
final log = LogProvider.of(context);
return ClockProvider(
child: CartProvider(
child: Scaffold(
appBar: AppBar(title: const Text('Example 14 - the inherited data')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
const _PageTime(),
const Catalog(),
const CartSummary(),
const SizedBox(height: 12),
Text('Log (provided to the whole application)', style: Theme.of(context).textTheme.titleSmall),
for (final line in log.lines) Text(line, style: const TextStyle(fontSize: 12)),
],
),
),
),
);
}
}
|
- Zeilen 22–24: Der Protokoll-Provider wird über [MaterialApp] platziert: Das Protokoll steht in der GESAMTEN Anwendung zur Verfügung, auch in Fenstern und auf anderen Bildschirmen;
- Zeilen 34–40: ein kleines Widget, das unterhalb des Uhr-Providers der Seite platziert ist;
- Zeile 50: Die Seite liest das Protokoll; sie wird bei jeder neuen Zeile neu aufgebaut;
- Zeilen 51–52: Die Seite stellt eine Uhr (Standardperiode: eine Sekunde) und einen Warenkorb für alles bereit, was sie enthält.
Wir fügen drei Artikel hinzu und entfernen dann einen:

Die Uhr der Seite geht jede Sekunde weiter; die Uhr des Warenkorbs alle fünf Sekunden. Das Protokoll zeigt die Hinzufügungen und das Entfernen. Beispiel 20 wird diese ganze Arbeit an das Paket [provider] delegieren, das sie in einer einzigen Zeile schreibt, dabei aber genau auf diesem Mechanismus beruht.
4.6. Beispiel 15: Verhalten wiederverwenden
Ein Widget verwendet eine Ansicht wieder. Wie verwenden Sie ein Verhalten samt seinem Zustand wieder (das Antippen hervorheben, nach langem Drücken eine Aktion auslösen, beim Start den Fokus setzen)? [React] hat „Custom Hooks“; [Flutter] und [Dart] bieten drei Werkzeuge.
| // =========================================================================
// lib/ex15_behaviors/highlighter.dart - ein Verhalten in einem Widget
// -------------------------------------------------------------------------
// Die erste Möglichkeit, ein VERHALTEN (mit seinem Zustand) wiederzuverwenden: ein
// "Wrapper"-Widget, das dieses Verhalten zu jedem Kind hinzufügt.
// Highlighter(color: ..., child: ListTile(...))
// Dieses hebt sein Kind hervor, solange es BERÜHRT wird (der Finger liegt auf
// dem Bildschirm), und, mit einer Maus (Web, Computer), solange der Mauszeiger darüber SCHWEBT.
// Jeder Highlighter hat seinen eigenen Zustand: Zwei Zeilen stören sich nicht.
// =========================================================================
import 'package:flutter/material.dart';
class Highlighter extends StatefulWidget {
final Color color;
final Widget child;
const Highlighter({super.key, this.color = const Color(0xFFFFF3CD), required this.child});
@override
State<Highlighter> createState() => _HighlighterState();
}
class _HighlighterState extends State<Highlighter> {
bool _touched = false;
bool _hovered = false;
@override
Widget build(BuildContext context) {
// MouseRegion: die Mausbewegungen; Listener: die Berührungen
// des Fingers (oder die Klicks), auf der untersten Ebene
return MouseRegion(
onEnter: (_) => setState(() => _hovered = true),
onExit: (_) => setState(() => _hovered = false),
child: Listener(
onPointerDown: (_) => setState(() => _touched = true),
onPointerUp: (_) => setState(() => _touched = false),
onPointerCancel: (_) => setState(() => _touched = false),
// AnimatedContainer: eine ANIMIERTE Farbänderung (200 ms)
child: AnimatedContainer(
duration: const Duration(milliseconds: 200),
color: _touched || _hovered ? widget.color : Colors.transparent,
child: widget.child,
),
),
);
}
}
|
- Zeilen 32–34: [MouseRegion] meldet, wenn die Maus das Widget betritt oder verlässt (im Web oder auf einem Computer; ein Smartphone hat keine Maus);
- Zeilen 35–38: [Listener] meldet auf niedrigster Ebene jede Fingerberührung (oder jeden Klick): Drücken, Loslassen, Abbrechen;
- Zeilen 40–42: ein animierter [Container]: Ändert sich seine Farbe, geht er in 200 Millisekunden von der alten zur neuen Farbe über, ohne dass zusätzlicher Code erforderlich ist. [Flutter] hat eine ganze Familie solcher „implizit animierter“ Widgets: [AnimatedOpacity], [AnimatedPadding], [AnimatedAlign]...
[Highlighter] wendet sein Verhalten auf jedes beliebige Kind an: [Highlighter(child: ListTile(...))].
| // =========================================================================
// lib/ex15_behaviors/long_press.dart - eine Schaltfläche für langes Drücken
// -------------------------------------------------------------------------
// LongPressButton(duration: Duration(seconds: 1), onAction: remove, child: ...)
// Die Aktion wird nur ausgeführt, wenn die Schaltfläche die
// gesamte Dauer gedrückt gehalten wird: ein Schutz vor versehentlichem Drücken. Ein Ring
// füllt sich während des Drückens.
// Das Füllen ist eine ANIMATION: Ein AnimationController erzeugt einen
// Wert, der während der angegebenen Dauer von 0 auf 1 geht, bei jedem Frame
// des Bildschirms. Er braucht einen "Ticker" (den Herzschlag der Frames): Das Mixin
// SingleTickerProviderStateMixin fügt ihn dem State-Objekt hinzu. Ein MIXIN ist
// der Weg von Dart, Code in mehreren Klassen wiederzuverwenden (siehe
// autofocus.dart).
// =========================================================================
import 'package:flutter/material.dart';
class LongPressButton extends StatefulWidget {
final Duration duration;
final VoidCallback onAction;
final Widget child;
const LongPressButton({
super.key,
this.duration = const Duration(seconds: 1),
required this.onAction,
required this.child,
});
@override
State<LongPressButton> createState() => _LongPressButtonState();
}
// "with": Das State-Objekt erhält zusätzlich den Code des Mixins
class _LongPressButtonState extends State<LongPressButton> with SingleTickerProviderStateMixin {
late final AnimationController _animation;
@override
void initState() {
super.initState();
// vsync: this: der vom Mixin bereitgestellte Ticker
_animation = AnimationController(vsync: this, duration: widget.duration)
// das Ende der Animation: Das Drücken dauerte lange genug
..addStatusListener((status) {
if (status == AnimationStatus.completed) {
_animation.reset();
widget.onAction();
}
});
}
// wenn das Widget entfernt wird: keine verwaiste Animation
@override
void dispose() {
_animation.dispose();
super.dispose();
}
void _start() => _animation.forward(from: 0);
// der Finger wird zu früh gehoben: Der Ring leert sich
void _stop() {
if (_animation.isAnimating) _animation.reverse();
}
@override
Widget build(BuildContext context) {
return GestureDetector(
onTapDown: (_) => _start(),
onTapUp: (_) => _stop(),
onTapCancel: _stop,
// AnimatedBuilder: baut NUR dieses Stück bei jedem Frame neu
child: AnimatedBuilder(
animation: _animation,
builder: (context, child) => Row(
mainAxisSize: MainAxisSize.min,
children: [
SizedBox(
width: 22,
height: 22,
child: CircularProgressIndicator(value: _animation.value, strokeWidth: 3, color: Colors.red),
),
const SizedBox(width: 8),
child!, // das Kind, ein für alle Mal gebaut
],
),
child: widget.child,
),
);
}
}
|
- Zeile 35: [with]: Das [State]-Objekt erhält außerdem den Code eines Mixins. Ein Mixin ist die Art, wie [Dart] Code über mehrere Klassen hinweg ohne Vererbung wiederverwendet. Dieses Mixin stellt einen „Ticker“ bereit – die Bildwiederholrate des Bildschirms (60 Bilder pro Sekunde oder mehr) –, den eine Animation benötigt;
- Zeilen 42–47: Ein [AnimationController] erzeugt für jedes Bild einen Wert von 0 bis 1 über die angegebene Dauer. [vsync: this]: der vom Mixin bereitgestellte Ticker. [..addStatusListener(...)]: Erreicht die Animation ihr Ende ([completed]), hat das Drücken lange genug gedauert: Die Animation wird auf null zurückgesetzt und die Aktion ausgeführt;
- Zeilen 59–63: Der Finger berührt die Schaltfläche: Die Animation startet bei 0; hebt er sich zu früh, läuft die Animation zurück;
- Zeilen 69–71: Gesten: drücken, loslassen, abbrechen (der Finger ist von der Schaltfläche abgerutscht);
- Zeilen 73–87: [AnimatedBuilder] baut nur diesen Teil des Bildschirms für jedes Bild der Animation neu auf: einen Ring ([CircularProgressIndicator]), dessen Wert der Animation entspricht. Das feste Element (der Text der Schaltfläche) wird ein für alle Mal erzeugt ([child]) und an [builder] übergeben.
4.6.3. Ein Verhalten in einem Mixin
| // =========================================================================
// lib/ex15_behaviors/autofocus.dart - ein Verhalten in einem MIXIN
// -------------------------------------------------------------------------
// Die zweite Möglichkeit, ein Verhalten wiederzuverwenden: ein Mixin auf State.
// class _MyPageState extends State<MyPage> with FocusOnStart { ... }
// Das State-Objekt erhält einen FocusNode (startFocus), der den Fokus übernimmt,
// sobald der Bildschirm angezeigt wird, und der mit ihm freigegeben wird: Das Mixin
// ergänzt initState und dispose der Klasse, die es verwendet.
// "on State<T>": Dieses Mixin lässt sich nur auf ein State-Objekt anwenden, dessen
// Methoden es daher nutzen kann (initState, dispose, mounted ...).
// (Für ein einfaches Feld bewirkt der Parameter autofocus: true von TextField
// dasselbe: Das Mixin zeigt den Mechanismus, der für anderes wiederverwendbar ist.)
// =========================================================================
import 'package:flutter/widgets.dart';
mixin FocusOnStart<T extends StatefulWidget> on State<T> {
final startFocus = FocusNode();
@override
void initState() {
super.initState(); // das initState der Klasse (oder des Mixins) "darüber"
// nach der ersten Anzeige: Das Feld existiert, es erhält den Fokus
WidgetsBinding.instance.addPostFrameCallback((_) {
if (mounted) startFocus.requestFocus();
});
}
@override
void dispose() {
startFocus.dispose();
super.dispose();
}
}
|
- Zeile 17: ein Mixin, das nur auf ein [State] -Objekt ([on State<T>]) angewendet wird: Es kann daher dessen Methoden verwenden;
- Zeile 18: Das [State]-Objekt, das das Mixin verwendet, erhält dieses Feld;
- Zeilen 21–25: Das Mixin ergänzt [initState] : [super.initState()] ruft die Methode der „Eltern“-Klasse auf (der von [State] oder eines anderen Mixins). Nach der ersten Anzeige existiert das Feld: Es erhält den Fokus. [mounted]: Befindet sich das [State]-Objekt noch im Baum?;
- Zeilen 30–32: Es ergänzt außerdem [dispose], um den [FocusNode] freizugeben.
4.6.4. Verwendung
| // =========================================================================
// lib/ex15_behaviors/main.dart - Verhalten wiederverwenden
// -------------------------------------------------------------------------
// Drei Werkzeuge von Flutter und Dart, um ein VERHALTEN (und
// seinen Zustand) wiederzuverwenden, und nicht nur eine einfache Anzeige:
// - ein "Wrapper"-Widget (Highlighter);
// - ein Widget, das eine Animation trägt (LongPressButton);
// - ein Mixin auf State (FocusOnStart).
// =========================================================================
import 'package:flutter/material.dart';
import 'long_press.dart';
import 'autofocus.dart';
import 'highlighter.dart';
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const BehaviorsPage(),
),
);
}
class BehaviorsPage extends StatefulWidget {
const BehaviorsPage({super.key});
@override
State<BehaviorsPage> createState() => _BehaviorsPageState();
}
// das Mixin FocusOnStart: Dieses State-Objekt erhält startFocus
class _BehaviorsPageState extends State<BehaviorsPage> with FocusOnStart {
final List<String> _doctors = ['Mme Marie PELISSIER', 'Mr Paul TATOU', 'Melle Sophie DUPONT'];
String _message = '';
void _remove(String name) {
setState(() {
_doctors.remove(name);
_message = '$name has been deleted.';
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Example 15 - reusing behaviors')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
TextField(
focusNode: startFocus, // der vom Mixin bereitgestellte FocusNode
decoration: const InputDecoration(hintText: 'this field received the focus on its own'),
),
const SizedBox(height: 12),
const Text(
'Touch the rows; hold a button pressed for one second to delete.',
style: TextStyle(color: Colors.grey),
),
for (final (i, m) in _doctors.indexed)
Highlighter(
key: ValueKey(m),
// jede zweite Zeile: die Standardfarbe; die anderen grün
color: i.isEven ? const Color(0xFFFFF3CD) : const Color(0xFFD1E7DD),
child: ListTile(
title: Text(m),
trailing: LongPressButton(
onAction: () => _remove(m),
child: const Text('Delete', style: TextStyle(color: Colors.red)),
),
),
),
const SizedBox(height: 12),
if (_message.isNotEmpty) Text(_message, style: const TextStyle(color: Colors.indigo)),
],
),
);
}
}
|
- Zeile 35: Der Bildschirm verwendet das Mixin;
- Zeile 54: der vom Mixin bereitgestellte [FocusNode] ;
- Zeilen 63–71: Jede Zeile wird beim Antippen hervorgehoben; ihre Schaltfläche „Löschen“ wird erst wirksam, nachdem sie eine Sekunde lang gedrückt gehalten wurde.
Beim Gedrückthalten der ersten Schaltfläche (der Ring füllt sich, die Zeile wird hervorgehoben); dann nach vollständigem Drücken der zweiten Schaltfläche:
4.7. Beispiel 16: Ein wiederverwendbares Bestätigungsfenster
„Sind Sie sicher?“: [Flutter] liefert alles Notwendige. Die Funktion [showDialog] zeigt ein modales Fenster über dem Bildschirm an und gibt ein [Future] zurück, das mit dem Wert befüllt wird, den das Fenster beim Schließen übermittelt.
4.7.1. Das Fenster
| // =========================================================================
// lib/ex16_confirmation/confirmation.dart - "Sind Sie sicher?"
// -------------------------------------------------------------------------
// Flutter stellt alles Nötige bereit: showDialog() zeigt einen MODALEN
// Dialog über dem Bildschirm an und gibt ein Future zurück, das mit dem Wert aufgelöst wird,
// den der Dialog beim Schließen übergibt: Navigator.pop(context, value).
// Der aufrufende Code lässt sich daher sehr einfach schreiben:
//
// if (await confirm(context, 'Delete this doctor?')) { ... }
//
// Das Schließen des Dialogs OHNE Antwort (Tippen daneben, Zurück-Taste des
// Telefons, Esc-Taste) löst das Future mit null auf: Es wird als
// "Nein" behandelt.
// =========================================================================
import 'package:flutter/material.dart';
Future<bool> confirm(BuildContext context, String message) async {
final answer = await showDialog<bool>(
context: context,
// AlertDialog: ein Material-Dialog mit Titel, Inhalt und Schaltflächen
builder: (context) => AlertDialog(
title: const Text('Confirmation'),
content: Text(message),
actions: [
// autofocus: Die Schaltfläche "Nein" (die am wenigsten gefährliche Wahl) hat den Fokus
TextButton(autofocus: true, onPressed: () => Navigator.pop(context, false), child: const Text('No, go back')),
FilledButton(
style: FilledButton.styleFrom(backgroundColor: Colors.red),
onPressed: () => Navigator.pop(context, true),
child: const Text('Yes, confirm'),
),
],
),
);
return answer ?? false; // null: Dialog ohne Antwort geschlossen
}
|
- Zeile 18: eine Standardfunktion, die überall verwendet werden kann, wo ein [context] verfügbar ist;
- Zeilen 19–22: [showDialog] öffnet das von [builder] erzeugte Fenster und gibt ein [Future<bool?>] zurück: den Wert, der beim Schließen des Fensters übergeben wird;
- Zeilen 23–25: [AlertDialog] ist das Dialogfenster von [Material Design]: ein Titel, ein Inhalt und Schaltflächen;
- Zeile 27: [Navigator.pop(context, false)] schließt das Fenster und übermittelt dabei [false]. [autofocus]: Die Schaltfläche „Nein“ – die am wenigsten riskante Option – hat den Fokus (ein versehentliches Drücken der Eingabetaste löscht nichts);
- Zeile 36: Das Schließen des Fensters OHNE Antwort (Tippen außerhalb des Fensters, Drücken der Zurück-Taste des Smartphones oder der Esc-Taste) löst [Future] zu [null] auf: Dies wird als „Nein“ behandelt.
Der aufrufende Code ist dann genauso einfach zu schreiben wie mit [window.confirm] des Browsers: [if (await confirm(context, 'Delete this doctor?')) { ... }]. Der Client [React] benötigte einen Context, ein von Hand gebautes Promise und ein „Portal“, um dasselbe Ergebnis zu erzielen; mit [Flutter] funktionieren Fenster normalerweise so.
4.7.2. Verwendung
| // =========================================================================
// lib/ex16_confirmation/main.dart - den Bestätigungsdialog verwenden
// -------------------------------------------------------------------------
// Ein Löschen, dann eine kurzlebige Meldung am unteren Bildschirmrand (SnackBar),
// mit einer Schaltfläche "Rückgängig": die andere, auf Mobilgeräten sehr verbreitete Art,
// den Benutzer vor einem Fehler zu schützen.
// =========================================================================
import 'package:flutter/material.dart';
import 'confirmation.dart';
typedef Contact = ({int id, String name});
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const ContactsPage(),
),
);
}
class ContactsPage extends StatefulWidget {
const ContactsPage({super.key});
@override
State<ContactsPage> createState() => _ContactsPageState();
}
class _ContactsPageState extends State<ContactsPage> {
final List<Contact> _contacts = [
(id: 1, name: 'Jean MARTIN'),
(id: 2, name: 'Alice DURAND'),
(id: 3, name: 'Luc GERMAN'),
];
String _message = '';
// eine async-Funktion: Sie "wartet" auf die Antwort des Benutzers
Future<void> _remove(Contact c) async {
final yes = await confirm(context, 'Delete the contact ${c.name}?');
// nach einem await kann der Bildschirm verschwunden sein: Wir prüfen, ob er noch da ist
if (!mounted) return;
if (!yes) {
setState(() => _message = 'Deletion abandoned.');
return;
}
final position = _contacts.indexOf(c);
setState(() {
_contacts.remove(c);
_message = '${c.name} has been deleted.';
});
// ScaffoldMessenger: zeigt eine kurzlebige Meldung am unteren Bildschirmrand an
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(
content: Text('${c.name} deleted'),
action: SnackBarAction(
label: 'Undo',
onPressed: () => setState(() {
_contacts.insert(position, c);
_message = '${c.name} is back.';
}),
),
),
);
}
Future<void> _removeAll() async {
final yes = await confirm(context, 'Delete the ${_contacts.length} contacts?');
if (yes && mounted) {
setState(() {
_contacts.clear();
_message = 'All the contacts have been deleted.';
});
}
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Example 16 - a confirmation dialog')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
for (final c in _contacts)
ListTile(
leading: const Icon(Icons.person),
title: Text(c.name),
trailing: IconButton(
icon: const Icon(Icons.delete_outline, color: Colors.red),
onPressed: () => _remove(c),
),
),
if (_contacts.isEmpty)
const ListTile(
title: Text('No contact.', style: TextStyle(color: Colors.grey)),
),
const SizedBox(height: 12),
Align(
alignment: Alignment.centerLeft,
child: FilledButton(
style: FilledButton.styleFrom(backgroundColor: Colors.red),
// null: Schaltfläche deaktiviert, wenn die Liste leer ist
onPressed: _contacts.isEmpty ? null : _removeAll,
child: const Text('Delete all'),
),
),
const SizedBox(height: 12),
if (_message.isNotEmpty) Text(_message, style: const TextStyle(color: Colors.indigo)),
],
),
);
}
}
|
- Zeilen 41–44: eine [async]-Funktion: Sie wartet auf die Antwort des Benutzers. Nach einem [await] kann der Bildschirm verschwunden sein (der Benutzer hat ihn verlassen): Wir prüfen, ob er noch vorhanden ist ([mounted]), bevor wir den Zustand ändern oder [context] aufrufen. Der Analyzer meldet, wenn diese Prüfung fehlt;
- Zeilen 55–62: Nach dem Löschen erscheint am unteren Bildschirmrand eine vorübergehende Meldung ([SnackBar]) mit einer Schaltfläche „Rückgängig“, die den Kontakt an seiner ursprünglichen Position wiederherstellt. Das ist eine weitere, auf Mobilgeräten sehr verbreitete Methode, den Benutzer vor Fehlern zu schützen: sofort handeln, aber das Rückgängigmachen ermöglichen;
- Zeile 105: [null] deaktiviert die Schaltfläche, wenn die Liste leer ist.
Das Bestätigungsfenster; anschließend ist das Löschen abgeschlossen, mit seiner flüchtigen Meldung: