Results for “State”

state of a `TestTextInput` instance, a stub for the system's onscreen keyboard, is now reset between tests. The state of `WidgetTester.testTextInput` is now reset before

Prevent `StateError: Bad state: Future already completed in Symbolizer` during stack symbolization

the application is in when `WidgetsBindingObserver.didChangeAppLifecycleState` is called. If code has switch statements that handle all cases of the `AppLifecycleState` enum, a new case will need

ThemeData(); MaterialApp( theme: theme.copyWith( switchTheme: SwitchThemeData( thumbColor: MaterialStateProperty.resolveWith<Color?>( (Set states) { if (states.contains(MaterialState.disabled)) { return null; } if (states.contains(MaterialState.selected)) { return myColor

customize the checkbox. Code before migration: ```dart Checkbox( fillColor: MaterialStateProperty.resolveWith((states) { if (!states.contains(MaterialState.selected)) { return Colors.red; } return null; }), value: _checked, onChanged: _enabled ? (bool? value) { setState(() { _checked = value

rather than an `Intent(TheAction.key)` instance. Code before migration: ```dart class MyWidget extends StatelessWidget { // ... @override Widget build(BuildContext context) { return Shortcuts( shortcuts: <LogicalKeySet, Intent> { LogicalKeySet(LogicalKeyboardKey.enter): Intent(ActivateAction.key

states) => resolveCallback(states) ?? MouseCursor.uncontrolled; } BorderSide side = MaterialStateBorderSide.resolveWith((Set states) { if (states.contains(MaterialState.selected)) { return const BorderSide(color: Colors.red); } return null; }); ``` Code after migration: ```dart WidgetState selected

state exception can occur when HTTPS connection attempt errors or is aborted

Migrate to widget state (Material, by @ValentinVignal

Migrate to widget state (Material, by @ValentinVignal

device list parsing for long wireless mDNS serials separated from state by a single space

implicit rebuilds you may see issues, which can be resolved by wrapping any state change in a `setState` call. Prior to this change, an `OverlayEntry` would rebuild

logic statements in year2023 documentation (Material, by @xVemu

state restoration for UIScene migration (iOS, by @vashworth

Handle 'no permissions' adb device state (Tooling, by @mboetger

VoiceOver does not announce state of ButtonSegment (Material, by @huycozy). VoiceOver ButtonSegment

Ensures initial semantics state is sent to engine (Framework, by @chunhtai

SegmentedButton border doesn't reflect states (Material, by @bleroux). SegmentedButton

Windows] Propagate the enabled accessibility state (Windows, by @loic-peron-inetum-public

Update the doc on Google Testing to reflect the current state (Other changes, by @chingjun

Simplify `if-else` block into single `return` statement (Material, by @ValentinVignal

feat(IconButton): add property to specify a states controller (Material, by @ricardodalarme). IconButton

refactors `FlutterPlugin.kt` to use one line statement in the `into` bloc (Android, by @AbdeMohlbi). FlutterPlugin.kt

Semantics expanded state not updating in PopupMenuButton and DropdownButton (Material, by @AhmedLSayed9). PopupMenuButton DropdownButton

Material] modernize legacy switch statements to expressions across multiple files (Material, by @Enderjua

a11y][android] In Android 16, sendWindowContentChangeEvent when check state changes (Android, by @hannah

expansion tile is missing state announcement on non-Apple platforms (Material, by @huycozy

Restore OpenGL state modified by fl_compositor_opengl_present_layers (Linux, by @jason-simmons

radio list tile and switch list tile accept widget states controller (Material, by @AnishTiwari5077

tool): initialize asset isModified state on startup to prevent 2x hot restart slowdown (Tooling, by @kevmoo

Trackpad gestures on most platforms now send `PointerPanZoom` sequences and can trigger

build and every time it changes. Code before migration: ```dart class MyWidget extends StatelessWidget { @override Widget build(BuildContext context) { return FormField( autovalidate: true, builder: (FormFieldState state) { return

references to views. Before this change, the Android-specific platform code could lose state information about editable text fields when the app moved back to the foreground

DropdownButton` and `DropdownButtonFormField` now include an `enabled` property to explicitly manage their interactive state, and the `onChanged` callback is no longer marked as `required`. If you previously

migration: ```dart import 'package:material_ui/material_ui.dart'; void main() => runApp(Foo()); class Foo extends StatelessWidget { @override Widget build(BuildContext context) { return MediaQuery( data: const MediaQueryData(), child: Directionality( textDirection: TextDirection.ltr

were added to the `TargetPlatform` enum that could require additional cases in switch statements that switch on a `TargetPlatform` and don't include a `default:` case. The `TargetPlatform

your `TextInputClient` subclass. Code after migration: ```dart // Assume your `TextInputClient` is a `State` subclass, and it has a variable

migration: ```dart import 'package:cupertino_ui/cupertino_ui.dart'; void main() => runApp(Foo()); class Foo extends StatelessWidget { @override Widget build(BuildContext context) { return MediaQuery( data: const MediaQueryData(), child: CupertinoTabBar( items: const

overly complex code, and the old system didn't properly represent the true state of key events on the system. APIs provided by the Flutter framework

remember to dispose the new `ExpansibleController`. Code before migration: ```dart class _MyWidgetState extends State { final ExpansionTileController controller = ExpansionTileController(); @override Widget build(BuildContext context) { return ExpansionTile( controller: controller

Windows involves listening for Window messages in order to update the lifecycle state. In order for additional non-Flutter windows to affect the lifecycle state, they

enabled. Now, all `SnackBar` widgets with an action default to a non-dismissible state until the user interacts with the action button. This change aligns with

migration: ```dart final String myPath = myRoute.uri.path; ``` Code before migration: ```dart class MyObserverState extends State with WidgetsBindingObserver { @override Future didPushRoute(String route) => _handleRoute(route); } ``` Code after migration: ```dart

In order to ensure that libraries follow the latest OEM behavior, the

The Material and Cupertino design libraries are now available as standalone packages

A new set of basic material button widgets and themes have been

default items under the hood. No migration is needed: ```dart class _MyWidgetState extends State { @override Widget build(BuildContext context) { TextField( contextMenuBuilder: (BuildContext context, EditableTextState editableTextState) { return SystemContextMenu.editableText

output path: output-dir: lib/src/generated/i18n ``` 2. **Update imports**. Update your Dart import statements to point to the new location of the generated files: ```dart // Before import 'package:flutter

A new getter, `TextInputClient.currentAutofillScope`, was added to the `TextInputClient` interface; all `TextInputClient

radius: ```dart import 'package:material_ui/material_ui.dart'; void main() => runApp(Foo()); class Foo extends StatelessWidget { @override Widget build(BuildContext context) { return MaterialApp( home: Scaffold( floatingActionButton: FloatingActionButton(onPressed: () { showDialog( context

TextEditingController.buildTextSpan`. With the `BuildContext` available, users can access `InheritedWidgets` inside `buildTextSpan` to retrieve state required to style the text, or otherwise manipulate the created `TextSpan`. `TextEditingController.buildTextSpan

that used to call `MouseTracker.detachAnnotation`. This should not be a problem if no states are involved, otherwise you might want to add the mounted-exit check, especially

The `IconData` class is now marked as `final`, which prevents it from

expected to calculate the resulting size of the `RenderBox` without changing any internal state. It's essentially a dry run of `performLayout` that only calculates the resulting

overly complex code, and the old system didn't properly represent the true state of key events on the system. The Flutter framework libraries have already been