diff --git a/.vscode/launch.json b/.vscode/launch.json index deab51b0..cdbcd4c3 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -26,6 +26,27 @@ "type": "dart", "flutterMode": "release" }, + { + "name": "liquid-gen", + "cwd": "apps/liquid-gen", + "request": "launch", + "type": "dart" + }, + { + "name": "liquid-gen (profile mode)", + "cwd": "apps/liquid-gen", + "request": "launch", + "type": "dart", + "flutterMode": "profile" + }, + { + "name": "liquid-gen (release mode)", + "cwd": "apps/liquid-gen", + "request": "launch", + "type": "dart", + "flutterMode": "release" + }, + { "name": "Update goldens", "request": "launch", diff --git a/apps/liquid-gen/.gitignore b/apps/liquid-gen/.gitignore new file mode 100644 index 00000000..3820a95c --- /dev/null +++ b/apps/liquid-gen/.gitignore @@ -0,0 +1,45 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.build/ +.buildlog/ +.history +.svn/ +.swiftpm/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# The .vscode folder contains launch configuration and tasks you configure in +# VS Code which you may wish to be included in version control, so this line +# is commented out by default. +#.vscode/ + +# Flutter/Dart/Pub related +**/doc/api/ +**/ios/Flutter/.last_build_id +.dart_tool/ +.flutter-plugins-dependencies +.pub-cache/ +.pub/ +/build/ +/coverage/ + +# Symbolication related +app.*.symbols + +# Obfuscation related +app.*.map.json + +# Android Studio will place build artifacts here +/android/app/debug +/android/app/profile +/android/app/release diff --git a/apps/liquid-gen/.metadata b/apps/liquid-gen/.metadata new file mode 100644 index 00000000..d73f86e0 --- /dev/null +++ b/apps/liquid-gen/.metadata @@ -0,0 +1,30 @@ +# This file tracks properties of this Flutter project. +# Used by Flutter tool to assess capabilities and perform upgrades etc. +# +# This file should be version controlled and should not be manually edited. + +version: + revision: "bd7a4a6b5576630823ca344e3e684c53aa1a0f46" + channel: "stable" + +project_type: app + +# Tracks metadata for the flutter migrate command +migration: + platforms: + - platform: root + create_revision: bd7a4a6b5576630823ca344e3e684c53aa1a0f46 + base_revision: bd7a4a6b5576630823ca344e3e684c53aa1a0f46 + - platform: macos + create_revision: bd7a4a6b5576630823ca344e3e684c53aa1a0f46 + base_revision: bd7a4a6b5576630823ca344e3e684c53aa1a0f46 + + # User provided section + + # List of Local paths (relative to this file) that should be + # ignored by the migrate tool. + # + # Files that are not part of the templates will be ignored by default. + unmanaged_files: + - 'lib/main.dart' + - 'ios/Runner.xcodeproj/project.pbxproj' diff --git a/apps/liquid-gen/README.md b/apps/liquid-gen/README.md new file mode 100644 index 00000000..4af3a47a --- /dev/null +++ b/apps/liquid-gen/README.md @@ -0,0 +1,3 @@ +# liquid_gen + +A new Flutter project. diff --git a/apps/liquid-gen/analysis_options.yaml b/apps/liquid-gen/analysis_options.yaml new file mode 100644 index 00000000..f9b30346 --- /dev/null +++ b/apps/liquid-gen/analysis_options.yaml @@ -0,0 +1 @@ +include: package:flutter_lints/flutter.yaml diff --git a/apps/liquid-gen/lib/ai/genui_service.dart b/apps/liquid-gen/lib/ai/genui_service.dart new file mode 100644 index 00000000..8f8bd038 --- /dev/null +++ b/apps/liquid-gen/lib/ai/genui_service.dart @@ -0,0 +1,95 @@ +import 'package:flutter/foundation.dart'; +import 'package:genui/genui.dart' as genui; +import 'package:genui_google_generative_ai/genui_google_generative_ai.dart'; + +import '../catalog/liquid_catalog.dart'; +import '../services/api_key_service.dart'; +import 'system_instructions.dart'; + +/// GenUI service that manages the conversation and content generation +class GenUIService { + static final GenUIService instance = GenUIService._(); + GenUIService._(); + + genui.GenUiConversation? _conversation; + genui.A2uiMessageProcessor? _messageProcessor; + GoogleGenerativeAiContentGenerator? _contentGenerator; + ValueChanged? _onSurfaceAdded; + ValueChanged? _onSurfaceDeleted; + + /// Set callbacks for surface events + void setCallbacks({ + ValueChanged? onSurfaceAdded, + ValueChanged? onSurfaceDeleted, + }) { + _onSurfaceAdded = onSurfaceAdded; + _onSurfaceDeleted = onSurfaceDeleted; + } + + /// Initialize the GenUI conversation with Google Gemini + /// + /// Note: You may see a warning about "Unsupported keyword 'minItems'" when + /// GenUI adapts the catalog schema to function tool schemas. This is a known + /// GenUI limitation where `minItems` constraints are added to the `components` + /// property, which Gemini's function calling API doesn't support in that context. + /// The warning says "It will be ignored" and can be safely ignored - functionality + /// is not affected. See: https://github.com/flutter/genui/issues/428 + Future initialize() async { + // Get API key + final apiKey = await ApiKeyService.instance.getApiKey('gemini'); + if (apiKey == null || apiKey.isEmpty) { + throw Exception('Gemini API key not found. Please set it in settings.'); + } + + // Create message processor with Liquid Flutter catalog + _messageProcessor = genui.A2uiMessageProcessor( + catalogs: [LiquidCatalog.catalog], + ); + + // Create content generator + _contentGenerator = GoogleGenerativeAiContentGenerator( + catalog: LiquidCatalog.catalog, + systemInstruction: systemInstructions, + modelName: 'models/gemini-2.5-flash', + apiKey: apiKey, + ); + + // Create conversation + _conversation = genui.GenUiConversation( + contentGenerator: _contentGenerator!, + a2uiMessageProcessor: _messageProcessor!, + onSurfaceAdded: _onSurfaceAdded, + onSurfaceDeleted: _onSurfaceDeleted, + ); + } + + /// Get the GenUI conversation instance + genui.GenUiConversation? get conversation => _conversation; + + /// Get the message processor (host) for GenUiSurface + genui.A2uiMessageProcessor? get host => _messageProcessor; + + /// Send a message to the AI + Future sendMessage(String text) async { + if (_conversation == null) { + await initialize(); + } + _conversation?.sendRequest(genui.UserMessage.text(text)); + } + + /// Dispose resources + void dispose() { + _conversation?.dispose(); + _contentGenerator?.dispose(); + _messageProcessor?.dispose(); + _conversation = null; + _contentGenerator = null; + _messageProcessor = null; + } + + /// Reinitialize with new API key if needed + Future reinitialize() async { + dispose(); + await initialize(); + } +} diff --git a/apps/liquid-gen/lib/ai/system_instructions.dart b/apps/liquid-gen/lib/ai/system_instructions.dart new file mode 100644 index 00000000..adbe1ea4 --- /dev/null +++ b/apps/liquid-gen/lib/ai/system_instructions.dart @@ -0,0 +1,35 @@ +/// System instructions for GenUI to guide AI in using Liquid Flutter widgets correctly +const String systemInstructions = ''' +You are an expert UI generation assistant for Liquid Flutter. Your task is to generate Flutter widget trees using Liquid Flutter components. + +CRITICAL RULES: +1. You MUST use ONLY the widgets available in the catalog. Do NOT use Column, Row, or basic Flutter Container widgets. +2. Use LdAutoSpace instead of Column for arranging items vertically with automatic spacing. +3. Use LdContainer (from the catalog) for theme-aware containers, not the basic Flutter Container widget. +4. Use LdScaffold as the root widget for screens with LdAppBar and LdScaffoldBody. +5. Use LdScaffoldBody with addContainer: true for automatic padding. +6. Follow the Liquid Flutter design system patterns: + - Use LdText.h() for headlines + - Use LdText.p() for paragraphs + - Use LdText.l() for labels + - Use LdText.caption() for captions + - Use LdAutoSpace() for vertical layouts with automatic spacing + - Use LdCard with padding: EdgeInsets.zero when containing LdListItems + - Group related content in LdBundle or LdCard + +When generating UI: +1. Always start with LdScaffold as the root +2. Add LdAppBar in the appBars array if a title is needed +3. Use LdScaffoldBody with addContainer: true for the main content +4. Use LdAutoSpace for arranging widgets vertically +5. Use appropriate Liquid Flutter components from the catalog +6. Follow proper nesting and structure +7. Include appropriate properties for each widget + +Example structure: +- LdScaffold + - appBars: [LdAppBar with title] + - body: LdScaffoldBody + - addContainer: true + - children: [LdAutoSpace with content widgets] +'''; diff --git a/apps/liquid-gen/lib/catalog/liquid_catalog.dart b/apps/liquid-gen/lib/catalog/liquid_catalog.dart new file mode 100644 index 00000000..53f19a01 --- /dev/null +++ b/apps/liquid-gen/lib/catalog/liquid_catalog.dart @@ -0,0 +1,885 @@ +import 'package:flutter/material.dart'; +import 'package:genui/genui.dart'; +import 'package:json_schema_builder/json_schema_builder.dart'; +import 'package:liquid_flutter/liquid_flutter.dart'; + +/// Catalog of Liquid Flutter widgets for GenUI +class LiquidCatalog { + static Catalog get catalog => Catalog([ + ..._textWidgets, + ..._layoutWidgets, + ..._formWidgets, + ..._listWidgets, + ..._feedbackWidgets, + ..._otherWidgets, + ]); + + // Text widgets + static List get _textWidgets => [ + _ldTextH, + _ldTextHl, + _ldTextHs, + _ldTextHxs, + _ldTextP, + _ldTextPl, + _ldTextPs, + _ldTextPxs, + _ldTextL, + _ldTextLl, + _ldTextLs, + _ldTextLxs, + _ldTextCaption, + ]; + + static final _ldTextH = CatalogItem( + name: 'LdText.h', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The headline text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.h(text); + }, + ); + + static final _ldTextHl = CatalogItem( + name: 'LdText.hl', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The large headline text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.hl(text); + }, + ); + + static final _ldTextHs = CatalogItem( + name: 'LdText.hs', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The small headline text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.hs(text); + }, + ); + + static final _ldTextHxs = CatalogItem( + name: 'LdText.hxs', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The extra-small headline text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.hxs(text); + }, + ); + + static final _ldTextP = CatalogItem( + name: 'LdText.p', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The paragraph text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.p(text); + }, + ); + + static final _ldTextPl = CatalogItem( + name: 'LdText.pl', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The large paragraph text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.pl(text); + }, + ); + + static final _ldTextPs = CatalogItem( + name: 'LdText.ps', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The small paragraph text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.ps(text); + }, + ); + + static final _ldTextPxs = CatalogItem( + name: 'LdText.pxs', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The extra-small paragraph text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.pxs(text); + }, + ); + + static final _ldTextL = CatalogItem( + name: 'LdText.l', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The label text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.l(text); + }, + ); + + static final _ldTextLl = CatalogItem( + name: 'LdText.ll', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The large label text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.ll(text); + }, + ); + + static final _ldTextLs = CatalogItem( + name: 'LdText.ls', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The small label text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.ls(text); + }, + ); + + static final _ldTextLxs = CatalogItem( + name: 'LdText.lxs', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The extra-small label text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.lxs(text); + }, + ); + + static final _ldTextCaption = CatalogItem( + name: 'LdText.caption', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'The caption text to display'), + }, + required: ['text'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdText.caption(text); + }, + ); + + // Layout widgets + static List get _layoutWidgets => [ + _ldScaffold, + _ldAppBar, + _ldScaffoldBody, + _ldAutoSpace, + _ldCard, + _ldContainer, + ]; + + static final _ldScaffold = CatalogItem( + name: 'LdScaffold', + dataSchema: S.object( + properties: { + 'appBars': S.list(items: S.object()), + 'body': S.object(), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final appBarsJson = json['appBars'] as List?; + List? appBars; + if (appBarsJson != null) { + appBars = []; + for (final barData in appBarsJson) { + if (barData is Map) { + // Extract component name - GenUI data structure has component name as key + final componentId = barData.keys.firstOrNull; + if (componentId != null && componentId is String) { + final barWidget = itemContext.buildChild(componentId); + if (barWidget is LdAppBar) { + appBars.add(barWidget); + } + } + } + } + } + + final bodyData = json['body']; + Widget? child; + if (bodyData != null && bodyData is Map) { + // Extract component name from data structure + // GenUI expects data like {"LdScaffoldBody": {...}} or just the data with component id + final componentId = bodyData.keys.firstOrNull; + if (componentId != null && componentId is String) { + child = itemContext.buildChild(componentId); + } + } + return LdScaffold( + appBars: appBars, + body: child ?? const SizedBox(), + ); + }, + ); + + static final _ldAppBar = CatalogItem( + name: 'LdAppBar', + dataSchema: S.object( + properties: { + 'title': S.string(), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + Widget? title; + final titleData = json['title']; + if (titleData is String) { + title = LdText.h(titleData); + } else if (titleData != null && titleData is Map) { + // Extract component name from data structure + final componentId = titleData.keys.firstOrNull; + if (componentId != null && componentId is String) { + title = itemContext.buildChild(componentId); + } + } + return LdAppBar(title: title); + }, + ); + + static final _ldScaffoldBody = CatalogItem( + name: 'LdScaffoldBody', + dataSchema: S.object( + properties: { + 'addContainer': S.boolean(description: 'Whether to add container padding'), + 'children': S.list(items: S.object()), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final addContainer = json['addContainer'] as bool? ?? false; + final childrenJson = json['children'] as List?; + final children = childrenJson + ?.map((child) { + if (child is Map) { + final componentId = child.keys.firstOrNull; + if (componentId != null && componentId is String) { + return itemContext.buildChild(componentId); + } + } + return null; + }) + .whereType() + .toList() ?? + []; + return LdScaffoldBody( + addContainer: addContainer, + children: children, + ); + }, + ); + + static final _ldAutoSpace = CatalogItem( + name: 'LdAutoSpace', + dataSchema: S.object( + properties: { + 'children': S.list(items: S.object()), + }, + required: ['children'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final childrenJson = json['children'] as List? ?? []; + final children = childrenJson + .map((child) { + if (child is Map) { + final componentId = child.keys.firstOrNull; + if (componentId != null && componentId is String) { + return itemContext.buildChild(componentId); + } + } + return null; + }) + .whereType() + .toList(); + return LdAutoSpace(children: children); + }, + ); + + static final _ldCard = CatalogItem( + name: 'LdCard', + dataSchema: S.object( + properties: { + 'padding': S.object( + properties: { + 'left': S.number(), + 'top': S.number(), + 'right': S.number(), + 'bottom': S.number(), + }, + ), + 'child': S.object(), + 'children': S.list(items: S.object()), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final paddingJson = json['padding'] as Map?; + EdgeInsets? padding; + if (paddingJson != null) { + padding = EdgeInsets.fromLTRB( + (paddingJson['left'] as num?)?.toDouble() ?? 0, + (paddingJson['top'] as num?)?.toDouble() ?? 0, + (paddingJson['right'] as num?)?.toDouble() ?? 0, + (paddingJson['bottom'] as num?)?.toDouble() ?? 0, + ); + } + + Widget? child; + final childData = json['child']; + final childrenJson = json['children'] as List?; + if (childrenJson != null && childrenJson.isNotEmpty) { + final widgets = childrenJson + .map((c) { + if (c is Map) { + final componentId = c.keys.firstOrNull; + if (componentId != null && componentId is String) { + return itemContext.buildChild(componentId); + } + } + return null; + }) + .whereType() + .toList(); + if (widgets.isEmpty) { + child = null; + } else if (widgets.length == 1) { + child = widgets.first; + } else { + child = LdAutoSpace(children: widgets); + } + } else if (childData != null && childData is Map) { + // Extract component name from data structure + final componentId = childData.keys.firstOrNull; + if (componentId != null && componentId is String) { + child = itemContext.buildChild(componentId); + } + } + + return LdCard( + padding: padding, + child: child ?? const SizedBox(), + ); + }, + ); + + static final _ldContainer = CatalogItem( + name: 'LdContainer', + dataSchema: S.object( + properties: { + 'child': S.object(), + 'children': S.list(items: S.object()), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + Widget child = const SizedBox(); + final childData = json['child']; + final childrenJson = json['children'] as List?; + if (childrenJson != null && childrenJson.isNotEmpty) { + final widgets = childrenJson + .map((c) { + if (c is Map) { + final componentId = c.keys.firstOrNull; + if (componentId != null && componentId is String) { + return itemContext.buildChild(componentId); + } + } + return null; + }) + .whereType() + .toList(); + if (widgets.isNotEmpty) { + child = widgets.length == 1 + ? widgets.first + : LdAutoSpace(children: widgets); + } + } else if (childData != null && childData is Map) { + // Extract component name from data structure + final componentId = childData.keys.firstOrNull; + if (componentId != null && componentId is String) { + child = itemContext.buildChild(componentId); + } + } + return LdContainer(child: child); + }, + ); + + // Form widgets + static List get _formWidgets => [ + _ldButton, + _ldInput, + _ldCheckbox, + _ldSwitch, + _ldSelect, + _ldSlider, + ]; + + static final _ldButton = CatalogItem( + name: 'LdButton', + dataSchema: S.object( + properties: { + 'mode': S.string(description: 'Button mode variant: filled, outline, ghost, or vague'), + 'child': S.object(description: 'Button child as widget'), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + Widget? child; + final childData = json['child']; + if (childData != null && childData is Map) { + // Extract component name from data structure + final componentId = childData.keys.firstOrNull; + if (componentId != null && componentId is String) { + child = itemContext.buildChild(componentId); + } + } + + final modeStr = json['mode'] as String?; + LdButtonMode? mode; + if (modeStr != null) { + mode = switch (modeStr) { + 'outline' => LdButtonMode.outline, + 'ghost' => LdButtonMode.ghost, + 'vague' => LdButtonMode.vague, + _ => LdButtonMode.filled, + }; + } + + return LdButton( + mode: mode, + onPressed: () async {}, + child: child ?? const SizedBox(), + ); + }, + ); + + static final _ldInput = CatalogItem( + name: 'LdInput', + dataSchema: S.object( + properties: { + 'hint': S.string(description: 'Placeholder hint text'), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final hint = json['hint'] as String? ?? ''; + return LdInput( + hint: hint, + controller: null, + ); + }, + ); + + static final _ldCheckbox = CatalogItem( + name: 'LdCheckbox', + dataSchema: S.object( + properties: { + 'checked': S.boolean(description: 'Whether the checkbox is checked'), + 'label': S.string(description: 'Label text for the checkbox'), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + return LdCheckbox( + checked: json['checked'] as bool? ?? false, + label: json['label'] as String?, + onChanged: (_) {}, + ); + }, + ); + + static final _ldSwitch = CatalogItem( + name: 'LdSwitch', + dataSchema: S.object( + properties: { + 'value': S.boolean(description: 'Current switch value'), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final value = json['value'] as bool? ?? false; + return LdSwitch( + value: value, + children: {true: const Text('On'), false: const Text('Off')}, + onChanged: (_) {}, + ); + }, + ); + + static final _ldSelect = CatalogItem( + name: 'LdSelect', + dataSchema: S.object( + properties: { + 'value': S.string(description: 'Selected value'), + 'items': S.list( + items: S.object( + properties: { + 'value': S.string(), + 'label': S.string(), + }, + ), + ), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final value = json['value'] as String?; + final itemsJson = json['items'] as List?; + final items = itemsJson + ?.map((item) { + if (item is Map) { + final itemValue = item['value'] as String?; + final label = item['label'] as String? ?? itemValue ?? ''; + if (itemValue != null) { + return LdSelectItem( + value: itemValue, + child: Text(label), + ); + } + } + return null; + }) + .whereType>() + .toList() ?? + []; + return LdSelect( + value: value, + items: items, + onChanged: (_) {}, + ); + }, + ); + + static final _ldSlider = CatalogItem( + name: 'LdSlider', + dataSchema: S.object( + properties: { + 'hint': S.string(description: 'Hint text for the slider'), + 'label': S.string(description: 'Label text for the slider'), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + return LdSlider( + onSlideComplete: () {}, + hint: json['hint'] as String?, + label: json['label'] as String?, + ); + }, + ); + + // List widgets + static List get _listWidgets => [ + _ldList, + _ldListItem, + _ldListEmpty, + ]; + + static final _ldList = CatalogItem( + name: 'LdList', + dataSchema: S.object( + properties: { + 'children': S.list(items: S.object()), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final childrenJson = json['children'] as List? ?? []; + final items = childrenJson + .map((child) { + if (child is Map) { + final componentId = child.keys.firstOrNull; + if (componentId != null && componentId is String) { + return itemContext.buildChild(componentId); + } + } + return null; + }) + .whereType() + .toList(); + if (items.isEmpty) return const SizedBox(); + if (items.length == 1) return items.first; + return LdAutoSpace(children: items); + }, + ); + + static final _ldListItem = CatalogItem( + name: 'LdListItem', + dataSchema: S.object( + properties: { + 'title': S.string(), + 'children': S.list(items: S.object()), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + Widget? title; + final titleData = json['title']; + final childrenJson = json['children'] as List?; + if (childrenJson != null && childrenJson.isNotEmpty) { + final widgets = childrenJson + .map((c) { + if (c is Map) { + final componentId = c.keys.firstOrNull; + if (componentId != null && componentId is String) { + return itemContext.buildChild(componentId); + } + } + return null; + }) + .whereType() + .toList(); + if (widgets.isEmpty) { + title = null; + } else if (widgets.length == 1) { + title = widgets.first; + } else { + title = LdAutoSpace(children: widgets); + } + } else if (titleData is String) { + title = LdText.p(titleData); + } else if (titleData != null && titleData is Map) { + // Extract component name from data structure + final componentId = titleData.keys.firstOrNull; + if (componentId != null && componentId is String) { + title = itemContext.buildChild(componentId); + } + } + return LdListItem(title: title ?? const SizedBox()); + }, + ); + + static final _ldListEmpty = CatalogItem( + name: 'LdListEmpty', + dataSchema: S.object(), + widgetBuilder: (itemContext) { + return LdListEmpty(); + }, + ); + + // Feedback widgets + static List get _feedbackWidgets => [ + _ldHint, + ]; + + static final _ldHint = CatalogItem( + name: 'LdHint', + dataSchema: S.object( + properties: { + 'type': S.string(description: 'Hint type: info, error, warning, or success'), + 'message': S.string(description: 'Hint message text'), + 'child': S.object(), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + Widget child = const SizedBox(); + final childData = json['child']; + final message = json['message'] as String?; + if (childData != null && childData is Map) { + // Extract component name from data structure + final componentId = childData.keys.firstOrNull; + if (componentId != null && componentId is String) { + child = itemContext.buildChild(componentId); + } + } else if (message != null) { + child = LdText.p(message); + } + + final typeStr = json['type'] as String? ?? 'info'; + final hintType = switch (typeStr) { + 'error' => LdHintType.error, + 'warning' => LdHintType.warning, + 'success' => LdHintType.success, + _ => LdHintType.info, + }; + + return LdHint(type: hintType, child: child); + }, + ); + + // Other widgets + static List get _otherWidgets => [ + _ldBadge, + _ldTag, + _ldAvatar, + _ldDivider, + _ldBundle, + ]; + + static final _ldBadge = CatalogItem( + name: 'LdBadge', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'Badge text'), + 'child': S.object(), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + Widget child = const SizedBox(); + final childData = json['child']; + final text = json['text'] as String?; + if (childData != null && childData is Map) { + // Extract component name from data structure + final componentId = childData.keys.firstOrNull; + if (componentId != null && componentId is String) { + child = itemContext.buildChild(componentId); + } + } else if (text != null) { + child = Text(text); + } + return LdBadge(child: child); + }, + ); + + static final _ldTag = CatalogItem( + name: 'LdTag', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'Tag text'), + 'child': S.object(), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + Widget child = const SizedBox(); + final childData = json['child']; + final text = json['text'] as String?; + if (childData != null && childData is Map) { + // Extract component name from data structure + final componentId = childData.keys.firstOrNull; + if (componentId != null && componentId is String) { + child = itemContext.buildChild(componentId); + } + } else if (text != null) { + child = Text(text); + } + return LdTag(child: child); + }, + ); + + static final _ldAvatar = CatalogItem( + name: 'LdAvatar', + dataSchema: S.object( + properties: { + 'text': S.string(description: 'Avatar text/initials'), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final text = json['text'] as String? ?? ''; + return LdAvatar(child: Text(text)); + }, + ); + + static final _ldDivider = CatalogItem( + name: 'LdDivider', + dataSchema: S.object( + properties: { + 'height': S.number(description: 'Divider height'), + }, + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final height = (json['height'] as num?)?.toDouble(); + return LdDivider(height: height); + }, + ); + + static final _ldBundle = CatalogItem( + name: 'LdBundle', + dataSchema: S.object( + properties: { + 'children': S.list(items: S.object()), + }, + required: ['children'], + ), + widgetBuilder: (itemContext) { + final json = itemContext.data as Map; + final childrenJson = json['children'] as List? ?? []; + final children = childrenJson + .map((child) { + if (child is Map) { + final componentId = child.keys.firstOrNull; + if (componentId != null && componentId is String) { + return itemContext.buildChild(componentId); + } + } + return null; + }) + .whereType() + .toList(); + return LdBundle(children: children); + }, + ); +} diff --git a/apps/liquid-gen/lib/chat/chat_provider.dart b/apps/liquid-gen/lib/chat/chat_provider.dart new file mode 100644 index 00000000..f897acb6 --- /dev/null +++ b/apps/liquid-gen/lib/chat/chat_provider.dart @@ -0,0 +1,51 @@ +import 'package:flutter/foundation.dart'; + +class ChatMessage { + final String content; + final bool isUser; + final DateTime timestamp; + + ChatMessage({ + required this.content, + required this.isUser, + DateTime? timestamp, + }) : timestamp = timestamp ?? DateTime.now(); +} + +class ChatProvider extends ChangeNotifier { + final List _messages = []; + bool _isGenerating = false; + final Set _surfaceIds = {}; + + List get messages => List.unmodifiable(_messages); + bool get isGenerating => _isGenerating; + Set get surfaceIds => Set.unmodifiable(_surfaceIds); + + void addMessage(String content, {required bool isUser}) { + _messages.add(ChatMessage(content: content, isUser: isUser)); + notifyListeners(); + } + + void setGenerating(bool generating) { + if (_isGenerating != generating) { + _isGenerating = generating; + notifyListeners(); + } + } + + void addSurface(String surfaceId) { + _surfaceIds.add(surfaceId); + notifyListeners(); + } + + void removeSurface(String surfaceId) { + _surfaceIds.remove(surfaceId); + notifyListeners(); + } + + void clearMessages() { + _messages.clear(); + _surfaceIds.clear(); + notifyListeners(); + } +} diff --git a/apps/liquid-gen/lib/chat/chat_screen.dart b/apps/liquid-gen/lib/chat/chat_screen.dart new file mode 100644 index 00000000..8b5c06d2 --- /dev/null +++ b/apps/liquid-gen/lib/chat/chat_screen.dart @@ -0,0 +1,173 @@ +import 'package:flutter/material.dart'; + +import 'package:liquid_flutter/liquid_flutter.dart'; +import 'package:lucide_icons_flutter/lucide_icons.dart'; +import 'package:provider/provider.dart'; + +import '../ai/genui_service.dart'; +import '../preview/preview_provider.dart'; +import 'chat_provider.dart'; +import 'components/user_message.dart'; +import 'components/ai_message.dart'; +import 'components/loading_indicator.dart'; + +class ChatScreen extends StatefulWidget { + const ChatScreen({super.key}); + + @override + State createState() => _ChatScreenState(); +} + +class _ChatScreenState extends State { + final TextEditingController _inputController = TextEditingController( + text: "A simple login screen with a username and password field.", + ); + final ScrollController _scrollController = ScrollController(); + + @override + void initState() { + super.initState(); + WidgetsBinding.instance.addPostFrameCallback((_) { + _initializeGenUI(); + }); + } + + Future _initializeGenUI() async { + if (!mounted) return; + try { + GenUIService.instance.setCallbacks( + onSurfaceAdded: (update) { + if (!mounted) return; + final chatProvider = context.read(); + final previewProvider = context.read(); + chatProvider.addSurface(update.surfaceId); + previewProvider.setSurfaceIds(chatProvider.surfaceIds); + }, + onSurfaceDeleted: (update) { + if (!mounted) return; + final chatProvider = context.read(); + final previewProvider = context.read(); + chatProvider.removeSurface(update.surfaceId); + previewProvider.setSurfaceIds(chatProvider.surfaceIds); + }, + ); + await GenUIService.instance.initialize(); + } catch (e) { + if (mounted) { + final chatProvider = context.read(); + chatProvider.addMessage( + 'Error initializing GenUI: $e', + isUser: false, + ); + } + } + } + + @override + void dispose() { + _inputController.dispose(); + _scrollController.dispose(); + super.dispose(); + } + + void _scrollToBottom() { + WidgetsBinding.instance.addPostFrameCallback((_) { + if (_scrollController.hasClients) { + _scrollController.animateTo( + _scrollController.position.maxScrollExtent, + duration: const Duration(milliseconds: 300), + curve: Curves.easeOut, + ); + } + }); + } + + Future _sendMessage() async { + final chatProvider = context.read(); + final text = _inputController.text.trim(); + if (text.isEmpty || chatProvider.isGenerating) return; + + chatProvider.addMessage(text, isUser: true); + _inputController.clear(); + _scrollToBottom(); + + chatProvider.setGenerating(true); + _scrollToBottom(); + + try { + await GenUIService.instance.sendMessage(text); + chatProvider.addMessage( + 'Generating UI...', + isUser: false, + ); + } catch (e) { + chatProvider.addMessage( + 'Error: ${e.toString()}', + isUser: false, + ); + } finally { + chatProvider.setGenerating(false); + _scrollToBottom(); + } + } + + @override + Widget build(BuildContext context) { + final provider = context.watch(); + + return Padding( + padding: MediaQuery.paddingOf(context).add(EdgeInsets.all(8)), + child: Column( + children: [ + // Messages list + Expanded( + child: provider.messages.isEmpty + ? Center( + child: LdText.p( + 'Start a conversation to generate UI screens', + ), + ) + : ListView.builder( + controller: _scrollController, + padding: LdTheme.of(context).pad(size: LdSize.m), + itemCount: + provider.messages.length + + (provider.isGenerating ? 1 : 0), + itemBuilder: (context, index) { + if (index == provider.messages.length) { + return const LoadingIndicator(); + } + final message = provider.messages[index]; + return message.isUser + ? UserMessage(message: message) + : AIMessage(message: message); + }, + ), + ), + const LdDivider(height: 1), + // Input area + Container( + padding: LdTheme.of(context).pad(size: LdSize.m), + child: Row( + children: [ + Expanded( + child: LdInput( + controller: _inputController, + hint: 'Describe the UI you want to generate...', + onSubmitted: (_) => _sendMessage(), + ), + ), + const SizedBox(width: 8), + LdButton( + onPressed: _sendMessage, + disabled: provider.isGenerating, + child: const Icon(LucideIcons.send), + ), + ], + ), + ), + ], + ), + ); + } +} diff --git a/apps/liquid-gen/lib/chat/components/ai_message.dart b/apps/liquid-gen/lib/chat/components/ai_message.dart new file mode 100644 index 00000000..274e133f --- /dev/null +++ b/apps/liquid-gen/lib/chat/components/ai_message.dart @@ -0,0 +1,35 @@ +import 'package:flutter/material.dart'; + +import 'package:liquid_flutter/liquid_flutter.dart'; + +import '../chat_provider.dart'; + +class AIMessage extends StatelessWidget { + final ChatMessage message; + + const AIMessage({ + super.key, + required this.message, + }); + + @override + Widget build(BuildContext context) { + final theme = LdTheme.of(context); + return Padding( + padding: EdgeInsets.symmetric( + vertical: theme.pad(size: LdSize.s).vertical, + ), + child: Row( + mainAxisAlignment: MainAxisAlignment.start, + children: [ + Flexible( + child: LdCard( + padding: theme.pad(size: LdSize.m), + child: LdText.p(message.content), + ), + ), + ], + ), + ); + } +} diff --git a/apps/liquid-gen/lib/chat/components/loading_indicator.dart b/apps/liquid-gen/lib/chat/components/loading_indicator.dart new file mode 100644 index 00000000..bff7af62 --- /dev/null +++ b/apps/liquid-gen/lib/chat/components/loading_indicator.dart @@ -0,0 +1,25 @@ +import 'package:flutter/material.dart'; + +import 'package:liquid_flutter/liquid_flutter.dart'; + +class LoadingIndicator extends StatelessWidget { + const LoadingIndicator({super.key}); + + @override + Widget build(BuildContext context) { + final theme = LdTheme.of(context); + return Padding( + padding: EdgeInsets.symmetric( + vertical: theme.pad(size: LdSize.s).vertical, + ), + child: Row( + mainAxisAlignment: MainAxisAlignment.start, + children: [ + LdLoader(), + const SizedBox(width: 8), + LdText.l('Generating...'), + ], + ), + ); + } +} diff --git a/apps/liquid-gen/lib/chat/components/user_message.dart b/apps/liquid-gen/lib/chat/components/user_message.dart new file mode 100644 index 00000000..10837f4b --- /dev/null +++ b/apps/liquid-gen/lib/chat/components/user_message.dart @@ -0,0 +1,35 @@ +import 'package:flutter/material.dart'; + +import 'package:liquid_flutter/liquid_flutter.dart'; + +import '../chat_provider.dart'; + +class UserMessage extends StatelessWidget { + final ChatMessage message; + + const UserMessage({ + super.key, + required this.message, + }); + + @override + Widget build(BuildContext context) { + final theme = LdTheme.of(context); + return Padding( + padding: EdgeInsets.symmetric( + vertical: theme.pad(size: LdSize.s).vertical, + ), + child: Row( + mainAxisAlignment: MainAxisAlignment.end, + children: [ + Flexible( + child: LdCard( + padding: theme.pad(size: LdSize.m), + child: LdText.p(message.content), + ), + ), + ], + ), + ); + } +} diff --git a/apps/liquid-gen/lib/main.dart b/apps/liquid-gen/lib/main.dart new file mode 100644 index 00000000..f4e2304a --- /dev/null +++ b/apps/liquid-gen/lib/main.dart @@ -0,0 +1,80 @@ +import 'package:flutter/material.dart'; +import 'package:go_router/go_router.dart'; + +import 'package:liquid_flutter/liquid_flutter.dart'; +import 'package:liquid_flutter_window_utils/liquid_flutter_window_utils.dart'; + +import 'package:provider/provider.dart'; + +import 'router.dart'; +import 'schema/api_schema.dart'; + +void main() async { + // 1. Ensure Flutter binding is initialized + WidgetsFlutterBinding.ensureInitialized(); + + // 2. Configure GoRouter (if using go_router) + GoRouter.optionURLReflectsImperativeAPIs = true; + + // 3. Set up window callbacks for desktop platforms + LdAppBar.callbacks = LdWindowCallbacks( + onClose: () => LiquidFlutterWindowUtils.instance.closeWindow(), + onMinimize: () => LiquidFlutterWindowUtils.instance.minimizeWindow(), + onMaximize: () => LiquidFlutterWindowUtils.instance.maximizeWindow(), + onMove: () => LiquidFlutterWindowUtils.instance.startDragging(), + ); + + // 4. Listen for window ready events and configure window + LiquidFlutterWindowUtils.instance.windowReadyStream.listen((isReady) async { + if (isReady) { + await LiquidFlutterWindowUtils.instance.configureWindow(); + } + }); + + // 5. Load API schema + try { + await ApiSchema.instance.load(); + } catch (e) { + debugPrint('Warning: Failed to load API schema: $e'); + } + + // 6. Run the app + runApp(const LiquidGenApp()); +} + +class LiquidGenApp extends StatefulWidget { + const LiquidGenApp({super.key}); + + @override + State createState() => _LiquidGenAppState(); +} + +class _LiquidGenAppState extends State { + @override + Widget build(BuildContext context) { + return Provider( + create: (context) => AppRouter(), + child: Builder( + builder: (BuildContext context) { + return LdNotificationProvider( + child: LdThemeProvider( + screenRadiusStream: LiquidFlutterWindowUtils.instance.screenRadiusStream, + child: LdThemedAppBuilder( + appBuilder: (context, theme) { + final router = context.read().router; + return MaterialApp.router( + localizationsDelegates: LiquidLocalizations.localizationsDelegates, + title: 'Liquid Gen', + debugShowCheckedModeBanner: false, + theme: theme, + routerConfig: router, + ); + }, + ), + ), + ); + }, + ), + ); + } +} diff --git a/apps/liquid-gen/lib/preview/preview_provider.dart b/apps/liquid-gen/lib/preview/preview_provider.dart new file mode 100644 index 00000000..5c9353b3 --- /dev/null +++ b/apps/liquid-gen/lib/preview/preview_provider.dart @@ -0,0 +1,55 @@ +import 'package:flutter/foundation.dart'; + +import 'package:liquid_flutter_test_utils/ld_frame_options.dart'; +import 'package:liquid_flutter_test_utils/system_ui/iphone_16_pro.dart'; +import 'package:liquid_flutter_test_utils/system_ui/ipad_11_pro.dart'; +import 'package:liquid_flutter_test_utils/system_ui/fairphone_6.dart'; + +enum DeviceFrameType { + iphone16Pro, + ipadPro11, + fairphone6, +} + +class PreviewProvider extends ChangeNotifier { + DeviceFrameType _selectedFrame = DeviceFrameType.iphone16Pro; + final Set _surfaceIds = {}; + + DeviceFrameType get selectedFrame => _selectedFrame; + Set get surfaceIds => Set.unmodifiable(_surfaceIds); + + void setSelectedFrame(DeviceFrameType frame) { + if (_selectedFrame != frame) { + _selectedFrame = frame; + notifyListeners(); + } + } + + void setSurfaceIds(Set surfaceIds) { + _surfaceIds.clear(); + _surfaceIds.addAll(surfaceIds); + notifyListeners(); + } + + LdFrameOptions getFrameOptions() { + switch (_selectedFrame) { + case DeviceFrameType.iphone16Pro: + return iPhone16Pro; + case DeviceFrameType.ipadPro11: + return iPadPro11; + case DeviceFrameType.fairphone6: + return fairphone6; + } + } + + String getFrameLabel() { + switch (_selectedFrame) { + case DeviceFrameType.iphone16Pro: + return 'iPhone 16 Pro'; + case DeviceFrameType.ipadPro11: + return 'iPad Pro 11'; + case DeviceFrameType.fairphone6: + return 'Fairphone 6'; + } + } +} diff --git a/apps/liquid-gen/lib/preview/preview_screen.dart b/apps/liquid-gen/lib/preview/preview_screen.dart new file mode 100644 index 00000000..b3c79c79 --- /dev/null +++ b/apps/liquid-gen/lib/preview/preview_screen.dart @@ -0,0 +1,111 @@ +import 'package:flutter/material.dart'; + +import 'package:genui/genui.dart' as genui; +import 'package:liquid_flutter/liquid_flutter.dart'; +import 'package:liquid_flutter_test_utils/ld_frame.dart'; +import 'package:provider/provider.dart'; + +import '../ai/genui_service.dart'; +import 'preview_provider.dart'; + +class PreviewScreen extends StatelessWidget { + const PreviewScreen({super.key}); + + @override + Widget build(BuildContext context) { + final provider = context.watch(); + + return Padding( + padding: MediaQuery.paddingOf( + context, + ).atLeast(LdTheme.of(context).pad(size: LdSize.l)), + child: Column( + children: [ + // Device frame selector + Container( + padding: LdTheme.of(context).pad(size: LdSize.s), + child: Row( + children: DeviceFrameType.values.map((frame) { + final isSelected = frame == provider.selectedFrame; + final label = _getFrameLabel(frame); + return Expanded( + child: Padding( + padding: EdgeInsets.only( + right: frame != DeviceFrameType.values.last ? 8 : 0, + ), + child: LdButton( + mode: isSelected + ? LdButtonMode.filled + : LdButtonMode.outline, + onPressed: () => provider.setSelectedFrame(frame), + child: LdText.l(label), + ), + ), + ); + }).toList(), + ), + ), + const Divider(height: 1), + // Preview area + Expanded( + child: provider.surfaceIds.isEmpty + ? Center( + child: LdText.p( + 'No UI generated yet. Start a conversation to generate UI.', + ), + ) + : _buildPreview(context, provider), + ), + ], + ), + ); + } + + String _getFrameLabel(DeviceFrameType frame) { + switch (frame) { + case DeviceFrameType.iphone16Pro: + return 'iPhone 16 Pro'; + case DeviceFrameType.ipadPro11: + return 'iPad Pro 11'; + case DeviceFrameType.fairphone6: + return 'Fairphone 6'; + } + } + + Widget _buildPreview(BuildContext context, PreviewProvider provider) { + final frameOptions = provider.getFrameOptions(); + final host = GenUIService.instance.host; + final surfaceIds = provider.surfaceIds.toList(); + + if (host == null) { + return Center( + child: LdText.p('GenUI not initialized'), + ); + } + + return Center( + child: SizedBox( + width: frameOptions.width, + height: frameOptions.height, + child: Padding( + padding: LdTheme.of(context).pad(size: LdSize.l), + child: ldFrame( + child: surfaceIds.isEmpty + ? const SizedBox() + : ListView.builder( + itemCount: surfaceIds.length, + itemBuilder: (context, index) { + final surfaceId = surfaceIds[index]; + return genui.GenUiSurface( + host: host, + surfaceId: surfaceId, + ); + }, + ), + ldFrameOptions: frameOptions, + ), + ), + ), + ); + } +} diff --git a/apps/liquid-gen/lib/router.dart b/apps/liquid-gen/lib/router.dart new file mode 100644 index 00000000..cdd08b64 --- /dev/null +++ b/apps/liquid-gen/lib/router.dart @@ -0,0 +1,29 @@ +import 'package:go_router/go_router.dart'; + +import 'screens/main_screen.dart'; +import 'settings/settings_screen.dart'; + +class AppRouter { + AppRouter(); + + late final router = GoRouter( + debugLogDiagnostics: true, // Set to false in production + initialLocation: '/', + routes: [ + GoRoute( + path: '/', + pageBuilder: (context, state) => NoTransitionPage( + key: state.pageKey, + child: const MainScreen(), + ), + ), + GoRoute( + path: '/settings', + pageBuilder: (context, state) => NoTransitionPage( + key: state.pageKey, + child: const SettingsScreen(), + ), + ), + ], + ); +} diff --git a/apps/liquid-gen/lib/schema/api_schema.dart b/apps/liquid-gen/lib/schema/api_schema.dart new file mode 100644 index 00000000..17edc018 --- /dev/null +++ b/apps/liquid-gen/lib/schema/api_schema.dart @@ -0,0 +1,356 @@ +import 'dart:convert'; +import 'package:flutter/services.dart'; + +import '../widget_tree/widget_whitelist.dart'; + +class ApiSchema { + static final ApiSchema instance = ApiSchema._(); + ApiSchema._(); + + List? _schema; + + Future load() async { + if (_schema != null) return; + + try { + final String jsonString = await rootBundle.loadString( + '../../packages/liquid_flutter/api_guard/api.json', + ); + _schema = jsonDecode(jsonString) as List; + } catch (e) { + // If loading from packages path fails, try direct path + try { + final String jsonString = await rootBundle.loadString('api.json'); + _schema = jsonDecode(jsonString) as List; + } catch (e2) { + throw Exception('Failed to load API schema: $e2'); + } + } + } + + List? get schema => _schema; + + String? getSchemaSummary() { + if (_schema == null) return null; + + final buffer = StringBuffer(); + buffer.writeln('Available Liquid Flutter Components:'); + buffer.writeln(''); + + for (final item in _schema!) { + if (item is Map) { + final name = item['name'] as String?; + final description = item['description'] as String?; + if (name != null) { + buffer.writeln('- $name'); + if (description != null && description.isNotEmpty) { + buffer.writeln(' $description'); + } + final constructors = item['constructors'] as List?; + if (constructors != null && constructors.isNotEmpty) { + for (final constructor in constructors) { + if (constructor is Map) { + final constructorName = constructor['name'] as String?; + final signature = constructor['signature'] as List?; + if (signature != null && signature.isNotEmpty) { + buffer.write(' Constructor: $constructorName('); + final params = []; + for (final param in signature) { + if (param is Map) { + final paramName = param['name'] as String?; + final paramType = param['type'] as String?; + final required = param['required'] as bool? ?? false; + if (paramName != null && paramType != null) { + params.add( + '$paramType $paramName${required ? '' : '?'}', + ); + } + } + } + buffer.write(params.join(', ')); + buffer.writeln(')'); + } + } + } + } + buffer.writeln(''); + } + } + } + + return buffer.toString(); + } + + String? getComponentInfo(String componentName) { + if (_schema == null) return null; + + for (final item in _schema!) { + if (item is Map) { + final name = item['name'] as String?; + if (name == componentName) { + return jsonEncode(item); + } + } + } + return null; + } + + /// Get a compact schema summary showing only widget types and their property signatures + /// Format: WidgetName(prop1: Type, prop2?: Type) + String? getCompactSchemaSummary() { + if (_schema == null) return null; + + // Group widgets by category + final categories = >{ + 'Layout': [ + 'LdScaffold', + 'LdAppBar', + 'LdScaffoldBody', + 'LdAutoSpace', + 'LdBundle', + 'LdCard', + 'LdContainer', + ], + 'Text': [ + 'LdText', + 'LdText.h', + 'LdText.hl', + 'LdText.hs', + 'LdText.hxs', + 'LdText.p', + 'LdText.pl', + 'LdText.ps', + 'LdText.pxs', + 'LdText.l', + 'LdText.ll', + 'LdText.ls', + 'LdText.lxs', + 'LdText.caption', + ], + 'Form': [ + 'LdInput', + 'LdButton', + 'LdCheckbox', + 'LdRadio', + 'LdSwitch', + 'LdSelect', + 'LdSlider', + 'LdDatePicker', + 'LdTimePicker', + ], + 'List': [ + 'LdList', + 'LdListItem', + 'LdListEmpty', + 'LdListLoading', + ], + 'Feedback': [ + 'LdNotification', + 'LdHint', + 'LdLoading', + 'LdExceptionView', + ], + 'Modal': [ + 'LdSheet', + ], + 'Other': [ + 'LdBadge', + 'LdTag', + 'LdAvatar', + 'LdDivider', + 'LdAccordion', + 'LdBreadcrumb', + 'LdTable', + ], + }; + + final buffer = StringBuffer(); + buffer.writeln('Available Widget Types:'); + buffer.writeln(''); + + for (final categoryEntry in categories.entries) { + buffer.writeln('${categoryEntry.key}:'); + + for (final widgetType in categoryEntry.value) { + if (!WidgetWhitelist.isWhitelisted(widgetType)) continue; + + // Extract base class name for factory constructors + final baseClassName = widgetType.contains('.') + ? widgetType.split('.').first + : widgetType; + + final widgetInfo = _findWidgetInSchema(baseClassName); + if (widgetInfo != null) { + final signature = _extractCompactSignature(widgetInfo, widgetType); + buffer.writeln(' $widgetType$signature'); + } else { + // Widget not found in schema, just list the name + buffer.writeln(' $widgetType'); + } + } + + buffer.writeln(''); + } + + return buffer.toString(); + } + + /// Find widget information in schema + Map? _findWidgetInSchema(String widgetName) { + if (_schema == null) return null; + + for (final item in _schema!) { + if (item is Map) { + final name = item['name'] as String?; + if (name == widgetName) { + return item; + } + } + } + return null; + } + + /// Extract compact signature for a widget + String _extractCompactSignature( + Map widgetInfo, + String widgetType, + ) { + final constructors = widgetInfo['constructors'] as List?; + if (constructors == null || constructors.isEmpty) { + return '()'; + } + + Map? targetConstructor; + + // Handle factory constructors (e.g., LdText.h) + if (widgetType.contains('.')) { + final factoryName = widgetType.split('.').last; + for (final constructor in constructors) { + if (constructor is Map) { + final constructorName = constructor['name'] as String?; + if (constructorName == factoryName) { + targetConstructor = constructor; + break; + } + } + } + } + + // If no factory constructor found, use the first constructor + targetConstructor ??= constructors.first as Map?; + + if (targetConstructor == null) { + return '()'; + } + + final signature = targetConstructor['signature'] as List?; + if (signature == null || signature.isEmpty) { + return '()'; + } + + final params = []; + for (final param in signature) { + if (param is Map) { + final paramName = param['name'] as String?; + final paramType = param['type'] as String?; + final isRequired = param['required'] as bool? ?? false; + final isNamed = param['named'] as bool? ?? false; + + // Skip non-named parameters (positional) and key parameter + if (paramName == null || + paramName == 'key' || + (!isNamed && paramName != 'text')) { + continue; + } + + // Skip function types (callbacks) + if (paramType?.contains('Function') == true || + paramType?.contains('VoidCallback') == true || + paramType?.contains('ValueChanged') == true || + paramType?.contains('ValueSetter') == true || + paramType?.contains('ValueGetter') == true) { + continue; + } + + // Simplify type name + final simplifiedType = _simplifyType(paramType ?? 'dynamic'); + final optionalMarker = isRequired ? '' : '?'; + params.add('$paramName: $simplifiedType$optionalMarker'); + } + } + + if (params.isEmpty) { + return '()'; + } + + return '(${params.join(', ')})'; + } + + /// Simplify Dart type names for compact display + String _simplifyType(String dartType) { + // Handle nullable types + final isNullable = dartType.endsWith('?'); + final baseType = isNullable + ? dartType.substring(0, dartType.length - 1) + : dartType; + + // Handle List types + if (baseType.startsWith('List<')) { + final innerType = baseType.substring(5, baseType.length - 1); + final innerTypeNullable = innerType.endsWith('?'); + final innerBaseType = innerTypeNullable + ? innerType.substring(0, innerType.length - 1) + : innerType; + + if (innerBaseType == 'Widget' || + innerBaseType.startsWith('List ChatProvider()), + ChangeNotifierProvider(create: (_) => PreviewProvider()), + ], + child: LdScaffold( + appBars: [ + LdAppBar( + title: const Text('Liquid Gen'), + actions: [ + LdButton.ghost( + onPressed: () => context.push('/settings'), + child: const Icon(LucideIcons.settings), + ), + ], + ), + ], + body: Row( + children: [ + // Left side: Chat interface + Expanded(flex: 1, child: const ChatScreen()), + // Right side: Preview interface + Expanded(flex: 1, child: const PreviewScreen()), + ], + ), + ), + ); + } +} diff --git a/apps/liquid-gen/lib/services/api_key_service.dart b/apps/liquid-gen/lib/services/api_key_service.dart new file mode 100644 index 00000000..83309960 --- /dev/null +++ b/apps/liquid-gen/lib/services/api_key_service.dart @@ -0,0 +1,43 @@ +import 'package:flutter_secure_storage/flutter_secure_storage.dart'; + +class ApiKeyService { + static final ApiKeyService instance = ApiKeyService._(); + ApiKeyService._(); + + final FlutterSecureStorage _storage = const FlutterSecureStorage(); + + static const String _keyOpenAI = 'api_key_openai'; + static const String _keyAnthropic = 'api_key_anthropic'; + static const String _keyOllama = 'api_key_ollama'; + static const String _keyGemini = 'api_key_gemini'; + + String _getStorageKey(String provider) { + return switch (provider.toLowerCase()) { + 'openai' => _keyOpenAI, + 'anthropic' => _keyAnthropic, + 'ollama' => _keyOllama, + 'gemini' => _keyGemini, + _ => throw ArgumentError('Unknown provider: $provider'), + }; + } + + Future getApiKey(String provider) async { + final key = _getStorageKey(provider); + return await _storage.read(key: key); + } + + Future setApiKey(String provider, String apiKey) async { + final key = _getStorageKey(provider); + await _storage.write(key: key, value: apiKey); + } + + Future deleteApiKey(String provider) async { + final key = _getStorageKey(provider); + await _storage.delete(key: key); + } + + Future hasApiKey(String provider) async { + final apiKey = await getApiKey(provider); + return apiKey != null && apiKey.isNotEmpty; + } +} diff --git a/apps/liquid-gen/lib/settings/api_key_list_item.dart b/apps/liquid-gen/lib/settings/api_key_list_item.dart new file mode 100644 index 00000000..270bed90 --- /dev/null +++ b/apps/liquid-gen/lib/settings/api_key_list_item.dart @@ -0,0 +1,125 @@ +import 'package:flutter/material.dart'; + +import 'package:liquid_flutter/liquid_flutter.dart'; + +import '../services/api_key_service.dart'; +import '../ai/genui_service.dart'; + +class ApiKeyListItem extends StatelessWidget { + final String provider; + final String label; + + const ApiKeyListItem({ + super.key, + required this.provider, + required this.label, + }); + + @override + Widget build(BuildContext context) { + return LdSubmit( + config: LdSubmitConfig( + autoTrigger: true, + action: (_) async { + return await ApiKeyService.instance.hasApiKey(provider); + }, + ), + builder: LdSubmitCustomBuilder( + builder: (context, controller, stateType) { + return switch (stateType) { + LdSubmitStateType.loading => LdListItem.trailingForward( + title: Text(label), + subtitle: const LdLoader(), + onPressed: null, + ), + LdSubmitStateType.error => LdListItem.trailingForward( + title: Text(label), + subtitle: Text('Error loading API key status'), + onPressed: () async { + final currentKey = await ApiKeyService.instance.getApiKey( + provider, + ); + + if (!context.mounted) { + return; + } + final newKey = await ldEnterTextModal( + context: context, + title: Text(label), + description: 'Enter your API key for $label', + initialValue: currentKey, + inputHint: 'Enter API key', + inputLabel: 'API Key', + ); + if (!context.mounted) { + return; + } + + if (newKey != null) { + await _saveApiKey(context, newKey); + controller.trigger(); + } + }, + ), + LdSubmitStateType.result => LdListItem.trailingForward( + title: Text(label), + subtitle: Text( + controller.state.result == true + ? 'API key is configured' + : 'No API key configured', + ), + onPressed: () async { + final currentKey = await ApiKeyService.instance.getApiKey( + provider, + ); + if (!context.mounted) { + return; + } + final newKey = await ldEnterTextModal( + context: context, + title: Text(label), + description: 'Enter your API key for $label', + initialValue: currentKey, + inputHint: 'Enter API key', + inputLabel: 'API Key', + ); + if (!context.mounted) { + return; + } + + if (newKey != null) { + await _saveApiKey(context, newKey); + controller.trigger(); + } + }, + ), + LdSubmitStateType.idle => LdListItem.trailingForward( + title: Text(label), + subtitle: Text('Loading...'), + onPressed: null, + ), + }; + }, + ), + ); + } + + Future _saveApiKey(BuildContext context, String apiKey) async { + if (apiKey.trim().isNotEmpty) { + await ApiKeyService.instance.setApiKey(provider, apiKey.trim()); + } else { + await ApiKeyService.instance.deleteApiKey(provider); + } + + // Reinitialize GenUI service with new API key if it's Gemini + if (provider == 'gemini') { + await GenUIService.instance.reinitialize(); + } + + if (context.mounted) { + LdNotificationsController.of( + context, + ).success('API key saved successfully'); + } + } +} diff --git a/apps/liquid-gen/lib/settings/settings_screen.dart b/apps/liquid-gen/lib/settings/settings_screen.dart new file mode 100644 index 00000000..d197674f --- /dev/null +++ b/apps/liquid-gen/lib/settings/settings_screen.dart @@ -0,0 +1,38 @@ +import 'package:flutter/material.dart'; + +import 'package:liquid_flutter/liquid_flutter.dart'; + +import 'api_key_list_item.dart'; + +class SettingsScreen extends StatelessWidget { + const SettingsScreen({super.key}); + + @override + Widget build(BuildContext context) { + return LdScaffold( + appBars: [LdAppBar(title: Text('Settings'))], + body: LdScaffoldBody( + addContainer: true, + children: [ + LdText.h('API Keys'), + LdText.p( + 'Configure API keys for AI providers. Keys are stored securely on your device.', + ), + LdCard( + padding: EdgeInsets.zero, + child: Column( + children: [ + ApiKeyListItem(provider: 'openai', label: 'OpenAI'), + ApiKeyListItem(provider: 'anthropic', label: 'Anthropic'), + ApiKeyListItem(provider: 'gemini', label: 'Gemini'), + ], + ), + ), + LdText.caption( + 'Note: Ollama runs locally and does not require an API key.', + ), + ], + ), + ); + } +} diff --git a/apps/liquid-gen/lib/widget_tree/widget_whitelist.dart b/apps/liquid-gen/lib/widget_tree/widget_whitelist.dart new file mode 100644 index 00000000..f85d511e --- /dev/null +++ b/apps/liquid-gen/lib/widget_tree/widget_whitelist.dart @@ -0,0 +1,147 @@ +/// Whitelist of allowed UI-only widgets for widget tree generation. +/// Only presentation widgets from Liquid Flutter are allowed. +/// Logic widgets like Column, Row, Container are excluded. +class WidgetWhitelist { + /// Set of allowed widget type names + static const Set allowedWidgets = { + // Layout components + 'LdScaffold', + 'LdAppBar', + 'LdScaffoldBody', + 'LdAutoSpace', + 'LdBundle', + 'LdCard', + 'LdContainer', + // Text components + 'LdText', + 'LdText.h', + 'LdText.hl', + 'LdText.hs', + 'LdText.hxs', + 'LdText.p', + 'LdText.pl', + 'LdText.ps', + 'LdText.pxs', + 'LdText.l', + 'LdText.ll', + 'LdText.ls', + 'LdText.lxs', + 'LdText.caption', + // Form components + 'LdInput', + 'LdButton', + 'LdCheckbox', + 'LdRadio', + 'LdSwitch', + 'LdSelect', + 'LdSlider', + 'LdDatePicker', + 'LdTimePicker', + // List components + 'LdList', + 'LdListItem', + 'LdListEmpty', + 'LdListLoading', + // Feedback components + 'LdNotification', + 'LdHint', + 'LdLoading', + 'LdExceptionView', + // Modal components + 'LdSheet', + // Other components + 'LdBadge', + 'LdTag', + 'LdAvatar', + 'LdDivider', + 'LdAccordion', + 'LdBreadcrumb', + 'LdTable', + }; + + /// Check if a widget type is whitelisted + static bool isWhitelisted(String widgetType) { + return allowedWidgets.contains(widgetType); + } + + /// Get a formatted list of allowed widgets for prompts + static String getFormattedList() { + final buffer = StringBuffer(); + buffer.writeln('Allowed Widget Types:'); + buffer.writeln(''); + + // Group by category + final categories = >{ + 'Layout': [ + 'LdScaffold', + 'LdAppBar', + 'LdScaffoldBody', + 'LdAutoSpace', + 'LdBundle', + 'LdCard', + 'LdContainer', + ], + 'Text': [ + 'LdText', + 'LdText.h', + 'LdText.hl', + 'LdText.hs', + 'LdText.hxs', + 'LdText.p', + 'LdText.pl', + 'LdText.ps', + 'LdText.pxs', + 'LdText.l', + 'LdText.ll', + 'LdText.ls', + 'LdText.lxs', + 'LdText.caption', + ], + 'Form': [ + 'LdInput', + 'LdButton', + 'LdCheckbox', + 'LdRadio', + 'LdSwitch', + 'LdSelect', + 'LdSlider', + 'LdDatePicker', + 'LdTimePicker', + ], + 'List': [ + 'LdList', + 'LdListItem', + 'LdListEmpty', + 'LdListLoading', + ], + 'Feedback': [ + 'LdNotification', + 'LdHint', + 'LdLoading', + 'LdExceptionView', + ], + 'Modal': [ + 'LdSheet', + ], + 'Other': [ + 'LdBadge', + 'LdTag', + 'LdAvatar', + 'LdDivider', + 'LdAccordion', + 'LdBreadcrumb', + 'LdTable', + ], + }; + + for (final entry in categories.entries) { + buffer.writeln('${entry.key}:'); + for (final widget in entry.value) { + buffer.writeln(' - $widget'); + } + buffer.writeln(''); + } + + return buffer.toString(); + } +} diff --git a/apps/liquid-gen/macos/.gitignore b/apps/liquid-gen/macos/.gitignore new file mode 100644 index 00000000..746adbb6 --- /dev/null +++ b/apps/liquid-gen/macos/.gitignore @@ -0,0 +1,7 @@ +# Flutter-related +**/Flutter/ephemeral/ +**/Pods/ + +# Xcode-related +**/dgph +**/xcuserdata/ diff --git a/apps/liquid-gen/macos/Flutter/Flutter-Debug.xcconfig b/apps/liquid-gen/macos/Flutter/Flutter-Debug.xcconfig new file mode 100644 index 00000000..4b81f9b2 --- /dev/null +++ b/apps/liquid-gen/macos/Flutter/Flutter-Debug.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig" +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/apps/liquid-gen/macos/Flutter/Flutter-Release.xcconfig b/apps/liquid-gen/macos/Flutter/Flutter-Release.xcconfig new file mode 100644 index 00000000..5caa9d15 --- /dev/null +++ b/apps/liquid-gen/macos/Flutter/Flutter-Release.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig" +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/apps/liquid-gen/macos/Flutter/GeneratedPluginRegistrant.swift b/apps/liquid-gen/macos/Flutter/GeneratedPluginRegistrant.swift new file mode 100644 index 00000000..1a127e76 --- /dev/null +++ b/apps/liquid-gen/macos/Flutter/GeneratedPluginRegistrant.swift @@ -0,0 +1,18 @@ +// +// Generated file. Do not edit. +// + +import FlutterMacOS +import Foundation + +import device_info_plus +import flutter_secure_storage_macos +import liquid_flutter_window_utils +import path_provider_foundation + +func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) { + DeviceInfoPlusMacosPlugin.register(with: registry.registrar(forPlugin: "DeviceInfoPlusMacosPlugin")) + FlutterSecureStoragePlugin.register(with: registry.registrar(forPlugin: "FlutterSecureStoragePlugin")) + LiquidFlutterWindowUtilsPlugin.register(with: registry.registrar(forPlugin: "LiquidFlutterWindowUtilsPlugin")) + PathProviderPlugin.register(with: registry.registrar(forPlugin: "PathProviderPlugin")) +} diff --git a/apps/liquid-gen/macos/Podfile b/apps/liquid-gen/macos/Podfile new file mode 100644 index 00000000..ff5ddb3b --- /dev/null +++ b/apps/liquid-gen/macos/Podfile @@ -0,0 +1,42 @@ +platform :osx, '10.15' + +# CocoaPods analytics sends network stats synchronously affecting flutter build latency. +ENV['COCOAPODS_DISABLE_STATS'] = 'true' + +project 'Runner', { + 'Debug' => :debug, + 'Profile' => :release, + 'Release' => :release, +} + +def flutter_root + generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'ephemeral', 'Flutter-Generated.xcconfig'), __FILE__) + unless File.exist?(generated_xcode_build_settings_path) + raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure \"flutter pub get\" is executed first" + end + + File.foreach(generated_xcode_build_settings_path) do |line| + matches = line.match(/FLUTTER_ROOT\=(.*)/) + return matches[1].strip if matches + end + raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Flutter-Generated.xcconfig, then run \"flutter pub get\"" +end + +require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root) + +flutter_macos_podfile_setup + +target 'Runner' do + use_frameworks! + + flutter_install_all_macos_pods File.dirname(File.realpath(__FILE__)) + target 'RunnerTests' do + inherit! :search_paths + end +end + +post_install do |installer| + installer.pods_project.targets.each do |target| + flutter_additional_macos_build_settings(target) + end +end diff --git a/apps/liquid-gen/macos/Podfile.lock b/apps/liquid-gen/macos/Podfile.lock new file mode 100644 index 00000000..b5f2de67 --- /dev/null +++ b/apps/liquid-gen/macos/Podfile.lock @@ -0,0 +1,41 @@ +PODS: + - device_info_plus (0.0.1): + - FlutterMacOS + - flutter_secure_storage_macos (6.1.3): + - FlutterMacOS + - FlutterMacOS (1.0.0) + - liquid_flutter_window_utils (0.0.1): + - FlutterMacOS + - path_provider_foundation (0.0.1): + - Flutter + - FlutterMacOS + +DEPENDENCIES: + - device_info_plus (from `Flutter/ephemeral/.symlinks/plugins/device_info_plus/macos`) + - flutter_secure_storage_macos (from `Flutter/ephemeral/.symlinks/plugins/flutter_secure_storage_macos/macos`) + - FlutterMacOS (from `Flutter/ephemeral`) + - liquid_flutter_window_utils (from `Flutter/ephemeral/.symlinks/plugins/liquid_flutter_window_utils/macos`) + - path_provider_foundation (from `Flutter/ephemeral/.symlinks/plugins/path_provider_foundation/darwin`) + +EXTERNAL SOURCES: + device_info_plus: + :path: Flutter/ephemeral/.symlinks/plugins/device_info_plus/macos + flutter_secure_storage_macos: + :path: Flutter/ephemeral/.symlinks/plugins/flutter_secure_storage_macos/macos + FlutterMacOS: + :path: Flutter/ephemeral + liquid_flutter_window_utils: + :path: Flutter/ephemeral/.symlinks/plugins/liquid_flutter_window_utils/macos + path_provider_foundation: + :path: Flutter/ephemeral/.symlinks/plugins/path_provider_foundation/darwin + +SPEC CHECKSUMS: + device_info_plus: 1b14eed9bf95428983aed283a8d51cce3d8c4215 + flutter_secure_storage_macos: c2754d3483d20bb207bb9e5a14f1b8e771abcdb9 + FlutterMacOS: d0db08ddef1a9af05a5ec4b724367152bb0500b1 + liquid_flutter_window_utils: 08338c9de990e493e63db32a549aea6762e96c44 + path_provider_foundation: 0b743cbb62d8e47eab856f09262bb8c1ddcfe6ba + +PODFILE CHECKSUM: 54d867c82ac51cbd61b565781b9fada492027009 + +COCOAPODS: 1.16.2 diff --git a/apps/liquid-gen/macos/Runner.xcodeproj/project.pbxproj b/apps/liquid-gen/macos/Runner.xcodeproj/project.pbxproj new file mode 100644 index 00000000..787917a9 --- /dev/null +++ b/apps/liquid-gen/macos/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,839 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXAggregateTarget section */ + 33CC111A2044C6BA0003C045 /* Flutter Assemble */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */; + buildPhases = ( + 33CC111E2044C6BF0003C045 /* ShellScript */, + ); + dependencies = ( + ); + name = "Flutter Assemble"; + productName = FLX; + }; +/* End PBXAggregateTarget section */ + +/* Begin PBXBuildFile section */ + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C80D7294CF71000263BE5 /* RunnerTests.swift */; }; + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */ = {isa = PBXBuildFile; fileRef = 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */; }; + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC10F02044A3C60003C045 /* AppDelegate.swift */; }; + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F22044A3C60003C045 /* Assets.xcassets */; }; + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F42044A3C60003C045 /* MainMenu.xib */; }; + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */; }; + A8CD8ED09A425DB872B07950 /* Pods_RunnerTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 847E0CB72A1406A44683DBD5 /* Pods_RunnerTests.framework */; }; + BE2CDA67C6F4FBEDDE7B1008 /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 2B7CAD54681965ABE8C14BED /* Pods_Runner.framework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC10EC2044A3C60003C045; + remoteInfo = Runner; + }; + 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC111A2044C6BA0003C045; + remoteInfo = FLX; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 33CC110E2044A8840003C045 /* Bundle Framework */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Bundle Framework"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 029DE26BA3C2EB2D6BB57235 /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = ""; }; + 2B7CAD54681965ABE8C14BED /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 331C80D7294CF71000263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = ""; }; + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Warnings.xcconfig; sourceTree = ""; }; + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GeneratedPluginRegistrant.swift; sourceTree = ""; }; + 33CC10ED2044A3C60003C045 /* liquid_gen.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = liquid_gen.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 33CC10F02044A3C60003C045 /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 33CC10F22044A3C60003C045 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Assets.xcassets; path = Runner/Assets.xcassets; sourceTree = ""; }; + 33CC10F52044A3C60003C045 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/MainMenu.xib; sourceTree = ""; }; + 33CC10F72044A3C60003C045 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = Info.plist; path = Runner/Info.plist; sourceTree = ""; }; + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MainFlutterWindow.swift; sourceTree = ""; }; + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Debug.xcconfig"; sourceTree = ""; }; + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Release.xcconfig"; sourceTree = ""; }; + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = "Flutter-Generated.xcconfig"; path = "ephemeral/Flutter-Generated.xcconfig"; sourceTree = ""; }; + 33E51913231747F40026EE4D /* DebugProfile.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = DebugProfile.entitlements; sourceTree = ""; }; + 33E51914231749380026EE4D /* Release.entitlements */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.entitlements; path = Release.entitlements; sourceTree = ""; }; + 33E5194F232828860026EE4D /* AppInfo.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = AppInfo.xcconfig; sourceTree = ""; }; + 3E21D080EF47E94D21D1D8AA /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = ""; }; + 5AEDE6373C8AF1CA3CCB9463 /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = ""; }; + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = ""; }; + 847E0CB72A1406A44683DBD5 /* Pods_RunnerTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RunnerTests.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = ""; }; + A152440C987D18F6D7DB11D3 /* Pods-RunnerTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.release.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.release.xcconfig"; sourceTree = ""; }; + D3CAC89C4F6E72E76DA45E34 /* Pods-RunnerTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.debug.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.debug.xcconfig"; sourceTree = ""; }; + FCFABCD52D1BADA0B932CB8C /* Pods-RunnerTests.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.profile.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.profile.xcconfig"; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 331C80D2294CF70F00263BE5 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + A8CD8ED09A425DB872B07950 /* Pods_RunnerTests.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EA2044A3C60003C045 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + BE2CDA67C6F4FBEDDE7B1008 /* Pods_Runner.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 02A36C668829651B95FDA2D6 /* Pods */ = { + isa = PBXGroup; + children = ( + 029DE26BA3C2EB2D6BB57235 /* Pods-Runner.debug.xcconfig */, + 5AEDE6373C8AF1CA3CCB9463 /* Pods-Runner.release.xcconfig */, + 3E21D080EF47E94D21D1D8AA /* Pods-Runner.profile.xcconfig */, + D3CAC89C4F6E72E76DA45E34 /* Pods-RunnerTests.debug.xcconfig */, + A152440C987D18F6D7DB11D3 /* Pods-RunnerTests.release.xcconfig */, + FCFABCD52D1BADA0B932CB8C /* Pods-RunnerTests.profile.xcconfig */, + ); + path = Pods; + sourceTree = ""; + }; + 331C80D6294CF71000263BE5 /* RunnerTests */ = { + isa = PBXGroup; + children = ( + 331C80D7294CF71000263BE5 /* RunnerTests.swift */, + ); + path = RunnerTests; + sourceTree = ""; + }; + 33BA886A226E78AF003329D5 /* Configs */ = { + isa = PBXGroup; + children = ( + 33E5194F232828860026EE4D /* AppInfo.xcconfig */, + 9740EEB21CF90195004384FC /* Debug.xcconfig */, + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */, + ); + path = Configs; + sourceTree = ""; + }; + 33CC10E42044A3C60003C045 = { + isa = PBXGroup; + children = ( + 33FAB671232836740065AC1E /* Runner */, + 33CEB47122A05771004F2AC0 /* Flutter */, + 331C80D6294CF71000263BE5 /* RunnerTests */, + 33CC10EE2044A3C60003C045 /* Products */, + D73912EC22F37F3D000D13A0 /* Frameworks */, + 02A36C668829651B95FDA2D6 /* Pods */, + ); + sourceTree = ""; + }; + 33CC10EE2044A3C60003C045 /* Products */ = { + isa = PBXGroup; + children = ( + 33CC10ED2044A3C60003C045 /* liquid_gen.app */, + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 33CC11242044D66E0003C045 /* Resources */ = { + isa = PBXGroup; + children = ( + 33CC10F22044A3C60003C045 /* Assets.xcassets */, + 33CC10F42044A3C60003C045 /* MainMenu.xib */, + 33CC10F72044A3C60003C045 /* Info.plist */, + ); + name = Resources; + path = ..; + sourceTree = ""; + }; + 33CEB47122A05771004F2AC0 /* Flutter */ = { + isa = PBXGroup; + children = ( + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */, + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */, + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */, + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */, + ); + path = Flutter; + sourceTree = ""; + }; + 33FAB671232836740065AC1E /* Runner */ = { + isa = PBXGroup; + children = ( + 33CC10F02044A3C60003C045 /* AppDelegate.swift */, + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */, + 33E51913231747F40026EE4D /* DebugProfile.entitlements */, + 33E51914231749380026EE4D /* Release.entitlements */, + 33CC11242044D66E0003C045 /* Resources */, + 33BA886A226E78AF003329D5 /* Configs */, + ); + path = Runner; + sourceTree = ""; + }; + D73912EC22F37F3D000D13A0 /* Frameworks */ = { + isa = PBXGroup; + children = ( + 2B7CAD54681965ABE8C14BED /* Pods_Runner.framework */, + 847E0CB72A1406A44683DBD5 /* Pods_RunnerTests.framework */, + ); + name = Frameworks; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 331C80D4294CF70F00263BE5 /* RunnerTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */; + buildPhases = ( + 8A670901CFE59D84240EBE26 /* [CP] Check Pods Manifest.lock */, + 331C80D1294CF70F00263BE5 /* Sources */, + 331C80D2294CF70F00263BE5 /* Frameworks */, + 331C80D3294CF70F00263BE5 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 331C80DA294CF71000263BE5 /* PBXTargetDependency */, + ); + name = RunnerTests; + productName = RunnerTests; + productReference = 331C80D5294CF71000263BE5 /* RunnerTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 33CC10EC2044A3C60003C045 /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + 7DC83284199D174F0A2818AA /* [CP] Check Pods Manifest.lock */, + 33CC10E92044A3C60003C045 /* Sources */, + 33CC10EA2044A3C60003C045 /* Frameworks */, + 33CC10EB2044A3C60003C045 /* Resources */, + 33CC110E2044A8840003C045 /* Bundle Framework */, + 3399D490228B24CF009A79C7 /* ShellScript */, + E980EFF0B5974F373E9F8D6C /* [CP] Embed Pods Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + 33CC11202044C79F0003C045 /* PBXTargetDependency */, + ); + name = Runner; + productName = Runner; + productReference = 33CC10ED2044A3C60003C045 /* liquid_gen.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 33CC10E52044A3C60003C045 /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastSwiftUpdateCheck = 0920; + LastUpgradeCheck = 1510; + ORGANIZATIONNAME = ""; + TargetAttributes = { + 331C80D4294CF70F00263BE5 = { + CreatedOnToolsVersion = 14.0; + TestTargetID = 33CC10EC2044A3C60003C045; + }; + 33CC10EC2044A3C60003C045 = { + CreatedOnToolsVersion = 9.2; + LastSwiftMigration = 1100; + ProvisioningStyle = Automatic; + SystemCapabilities = { + com.apple.Sandbox = { + enabled = 1; + }; + }; + }; + 33CC111A2044C6BA0003C045 = { + CreatedOnToolsVersion = 9.2; + ProvisioningStyle = Manual; + }; + }; + }; + buildConfigurationList = 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 33CC10E42044A3C60003C045; + productRefGroup = 33CC10EE2044A3C60003C045 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 33CC10EC2044A3C60003C045 /* Runner */, + 331C80D4294CF70F00263BE5 /* RunnerTests */, + 33CC111A2044C6BA0003C045 /* Flutter Assemble */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 331C80D3294CF70F00263BE5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EB2044A3C60003C045 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */, + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 3399D490228B24CF009A79C7 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "echo \"$PRODUCT_NAME.app\" > \"$PROJECT_DIR\"/Flutter/ephemeral/.app_filename && \"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh embed\n"; + }; + 33CC111E2044C6BF0003C045 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + Flutter/ephemeral/FlutterInputs.xcfilelist, + ); + inputPaths = ( + Flutter/ephemeral/tripwire, + ); + outputFileListPaths = ( + Flutter/ephemeral/FlutterOutputs.xcfilelist, + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh && touch Flutter/ephemeral/tripwire"; + }; + 7DC83284199D174F0A2818AA /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-Runner-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; + 8A670901CFE59D84240EBE26 /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-RunnerTests-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; + E980EFF0B5974F373E9F8D6C /* [CP] Embed Pods Frameworks */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist", + ); + name = "[CP] Embed Pods Frameworks"; + outputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n"; + showEnvVarsInLog = 0; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 331C80D1294CF70F00263BE5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10E92044A3C60003C045 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */, + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */, + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 331C80DA294CF71000263BE5 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC10EC2044A3C60003C045 /* Runner */; + targetProxy = 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */; + }; + 33CC11202044C79F0003C045 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC111A2044C6BA0003C045 /* Flutter Assemble */; + targetProxy = 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 33CC10F42044A3C60003C045 /* MainMenu.xib */ = { + isa = PBXVariantGroup; + children = ( + 33CC10F52044A3C60003C045 /* Base */, + ); + name = MainMenu.xib; + path = Runner; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 331C80DB294CF71000263BE5 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = D3CAC89C4F6E72E76DA45E34 /* Pods-RunnerTests.debug.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.liquidGen.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/liquid_gen.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/liquid_gen"; + }; + name = Debug; + }; + 331C80DC294CF71000263BE5 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = A152440C987D18F6D7DB11D3 /* Pods-RunnerTests.release.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.liquidGen.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/liquid_gen.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/liquid_gen"; + }; + name = Release; + }; + 331C80DD294CF71000263BE5 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = FCFABCD52D1BADA0B932CB8C /* Pods-RunnerTests.profile.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.liquidGen.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/liquid_gen.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/liquid_gen"; + }; + name = Profile; + }; + 338D0CE9231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.15; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Profile; + }; + 338D0CEA231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + "CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = 2KG63XA6XL; + ENABLE_APP_SANDBOX = YES; + ENABLE_INCOMING_NETWORK_CONNECTIONS = NO; + ENABLE_OUTGOING_NETWORK_CONNECTIONS = YES; + ENABLE_RESOURCE_ACCESS_AUDIO_INPUT = NO; + ENABLE_RESOURCE_ACCESS_BLUETOOTH = NO; + ENABLE_RESOURCE_ACCESS_CALENDARS = NO; + ENABLE_RESOURCE_ACCESS_CAMERA = NO; + ENABLE_RESOURCE_ACCESS_CONTACTS = NO; + ENABLE_RESOURCE_ACCESS_LOCATION = NO; + ENABLE_RESOURCE_ACCESS_PRINTING = NO; + ENABLE_RESOURCE_ACCESS_USB = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Profile; + }; + 338D0CEB231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Profile; + }; + 33CC10F92044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.15; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + }; + name = Debug; + }; + 33CC10FA2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.15; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Release; + }; + 33CC10FC2044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + "CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = 2KG63XA6XL; + ENABLE_APP_SANDBOX = YES; + ENABLE_INCOMING_NETWORK_CONNECTIONS = NO; + ENABLE_OUTGOING_NETWORK_CONNECTIONS = YES; + ENABLE_RESOURCE_ACCESS_AUDIO_INPUT = NO; + ENABLE_RESOURCE_ACCESS_BLUETOOTH = NO; + ENABLE_RESOURCE_ACCESS_CALENDARS = NO; + ENABLE_RESOURCE_ACCESS_CAMERA = NO; + ENABLE_RESOURCE_ACCESS_CONTACTS = NO; + ENABLE_RESOURCE_ACCESS_LOCATION = NO; + ENABLE_RESOURCE_ACCESS_PRINTING = NO; + ENABLE_RESOURCE_ACCESS_USB = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + }; + name = Debug; + }; + 33CC10FD2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/Release.entitlements; + "CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = 2KG63XA6XL; + ENABLE_APP_SANDBOX = YES; + ENABLE_INCOMING_NETWORK_CONNECTIONS = NO; + ENABLE_OUTGOING_NETWORK_CONNECTIONS = YES; + ENABLE_RESOURCE_ACCESS_AUDIO_INPUT = NO; + ENABLE_RESOURCE_ACCESS_BLUETOOTH = NO; + ENABLE_RESOURCE_ACCESS_CALENDARS = NO; + ENABLE_RESOURCE_ACCESS_CAMERA = NO; + ENABLE_RESOURCE_ACCESS_CONTACTS = NO; + ENABLE_RESOURCE_ACCESS_LOCATION = NO; + ENABLE_RESOURCE_ACCESS_PRINTING = NO; + ENABLE_RESOURCE_ACCESS_USB = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Release; + }; + 33CC111C2044C6BA0003C045 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 33CC111D2044C6BA0003C045 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 331C80DB294CF71000263BE5 /* Debug */, + 331C80DC294CF71000263BE5 /* Release */, + 331C80DD294CF71000263BE5 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10F92044A3C60003C045 /* Debug */, + 33CC10FA2044A3C60003C045 /* Release */, + 338D0CE9231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10FC2044A3C60003C045 /* Debug */, + 33CC10FD2044A3C60003C045 /* Release */, + 338D0CEA231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC111C2044C6BA0003C045 /* Debug */, + 33CC111D2044C6BA0003C045 /* Release */, + 338D0CEB231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 33CC10E52044A3C60003C045 /* Project object */; +} diff --git a/apps/liquid-gen/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/apps/liquid-gen/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000..18d98100 --- /dev/null +++ b/apps/liquid-gen/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/apps/liquid-gen/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/apps/liquid-gen/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 00000000..89ab6bcd --- /dev/null +++ b/apps/liquid-gen/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,99 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/apps/liquid-gen/macos/Runner.xcworkspace/contents.xcworkspacedata b/apps/liquid-gen/macos/Runner.xcworkspace/contents.xcworkspacedata new file mode 100644 index 00000000..21a3cc14 --- /dev/null +++ b/apps/liquid-gen/macos/Runner.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,10 @@ + + + + + + + diff --git a/apps/liquid-gen/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/apps/liquid-gen/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 00000000..18d98100 --- /dev/null +++ b/apps/liquid-gen/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/apps/liquid-gen/macos/Runner/AppDelegate.swift b/apps/liquid-gen/macos/Runner/AppDelegate.swift new file mode 100644 index 00000000..b3c17614 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/AppDelegate.swift @@ -0,0 +1,13 @@ +import Cocoa +import FlutterMacOS + +@main +class AppDelegate: FlutterAppDelegate { + override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { + return true + } + + override func applicationSupportsSecureRestorableState(_ app: NSApplication) -> Bool { + return true + } +} diff --git a/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 00000000..a2ec33f1 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,68 @@ +{ + "images" : [ + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_16.png", + "scale" : "1x" + }, + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "2x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "1x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_64.png", + "scale" : "2x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_128.png", + "scale" : "1x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "2x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "1x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "2x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "1x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_1024.png", + "scale" : "2x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png new file mode 100644 index 00000000..82b6f9d9 Binary files /dev/null and b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png differ diff --git a/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png new file mode 100644 index 00000000..13b35eba Binary files /dev/null and b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png differ diff --git a/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png new file mode 100644 index 00000000..0a3f5fa4 Binary files /dev/null and b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png differ diff --git a/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png new file mode 100644 index 00000000..bdb57226 Binary files /dev/null and b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png differ diff --git a/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png new file mode 100644 index 00000000..f083318e Binary files /dev/null and b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png differ diff --git a/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png new file mode 100644 index 00000000..326c0e72 Binary files /dev/null and b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png differ diff --git a/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png new file mode 100644 index 00000000..2f1632cf Binary files /dev/null and b/apps/liquid-gen/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png differ diff --git a/apps/liquid-gen/macos/Runner/Base.lproj/MainMenu.xib b/apps/liquid-gen/macos/Runner/Base.lproj/MainMenu.xib new file mode 100644 index 00000000..80e867a4 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/Base.lproj/MainMenu.xib @@ -0,0 +1,343 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/apps/liquid-gen/macos/Runner/Configs/AppInfo.xcconfig b/apps/liquid-gen/macos/Runner/Configs/AppInfo.xcconfig new file mode 100644 index 00000000..79162aa7 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/Configs/AppInfo.xcconfig @@ -0,0 +1,14 @@ +// Application-level settings for the Runner target. +// +// This may be replaced with something auto-generated from metadata (e.g., pubspec.yaml) in the +// future. If not, the values below would default to using the project name when this becomes a +// 'flutter create' template. + +// The application's name. By default this is also the title of the Flutter window. +PRODUCT_NAME = liquid_gen + +// The application's bundle identifier +PRODUCT_BUNDLE_IDENTIFIER = com.example.liquidGen + +// The copyright displayed in application information +PRODUCT_COPYRIGHT = Copyright © 2026 com.example. All rights reserved. diff --git a/apps/liquid-gen/macos/Runner/Configs/Debug.xcconfig b/apps/liquid-gen/macos/Runner/Configs/Debug.xcconfig new file mode 100644 index 00000000..36b0fd94 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/Configs/Debug.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Debug.xcconfig" +#include "Warnings.xcconfig" diff --git a/apps/liquid-gen/macos/Runner/Configs/Release.xcconfig b/apps/liquid-gen/macos/Runner/Configs/Release.xcconfig new file mode 100644 index 00000000..dff4f495 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/Configs/Release.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Release.xcconfig" +#include "Warnings.xcconfig" diff --git a/apps/liquid-gen/macos/Runner/Configs/Warnings.xcconfig b/apps/liquid-gen/macos/Runner/Configs/Warnings.xcconfig new file mode 100644 index 00000000..42bcbf47 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/Configs/Warnings.xcconfig @@ -0,0 +1,13 @@ +WARNING_CFLAGS = -Wall -Wconditional-uninitialized -Wnullable-to-nonnull-conversion -Wmissing-method-return-type -Woverlength-strings +GCC_WARN_UNDECLARED_SELECTOR = YES +CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY = YES +CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE +CLANG_WARN__DUPLICATE_METHOD_MATCH = YES +CLANG_WARN_PRAGMA_PACK = YES +CLANG_WARN_STRICT_PROTOTYPES = YES +CLANG_WARN_COMMA = YES +GCC_WARN_STRICT_SELECTOR_MATCH = YES +CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK = YES +CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES +GCC_WARN_SHADOW = YES +CLANG_WARN_UNREACHABLE_CODE = YES diff --git a/apps/liquid-gen/macos/Runner/DebugProfile.entitlements b/apps/liquid-gen/macos/Runner/DebugProfile.entitlements new file mode 100644 index 00000000..b231432b --- /dev/null +++ b/apps/liquid-gen/macos/Runner/DebugProfile.entitlements @@ -0,0 +1,14 @@ + + + + + com.apple.security.app-sandbox + + com.apple.security.cs.allow-jit + + com.apple.security.network.server + + keychain-access-groups + + + diff --git a/apps/liquid-gen/macos/Runner/Info.plist b/apps/liquid-gen/macos/Runner/Info.plist new file mode 100644 index 00000000..4789daa6 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/Info.plist @@ -0,0 +1,32 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIconFile + + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + LSMinimumSystemVersion + $(MACOSX_DEPLOYMENT_TARGET) + NSHumanReadableCopyright + $(PRODUCT_COPYRIGHT) + NSMainNibFile + MainMenu + NSPrincipalClass + NSApplication + + diff --git a/apps/liquid-gen/macos/Runner/MainFlutterWindow.swift b/apps/liquid-gen/macos/Runner/MainFlutterWindow.swift new file mode 100644 index 00000000..3cc05eb2 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/MainFlutterWindow.swift @@ -0,0 +1,15 @@ +import Cocoa +import FlutterMacOS + +class MainFlutterWindow: NSWindow { + override func awakeFromNib() { + let flutterViewController = FlutterViewController() + let windowFrame = self.frame + self.contentViewController = flutterViewController + self.setFrame(windowFrame, display: true) + + RegisterGeneratedPlugins(registry: flutterViewController) + + super.awakeFromNib() + } +} diff --git a/apps/liquid-gen/macos/Runner/Release.entitlements b/apps/liquid-gen/macos/Runner/Release.entitlements new file mode 100644 index 00000000..0833c1b4 --- /dev/null +++ b/apps/liquid-gen/macos/Runner/Release.entitlements @@ -0,0 +1,10 @@ + + + + + com.apple.security.app-sandbox + + keychain-access-groups + + + diff --git a/apps/liquid-gen/macos/RunnerTests/RunnerTests.swift b/apps/liquid-gen/macos/RunnerTests/RunnerTests.swift new file mode 100644 index 00000000..61f3bd1f --- /dev/null +++ b/apps/liquid-gen/macos/RunnerTests/RunnerTests.swift @@ -0,0 +1,12 @@ +import Cocoa +import FlutterMacOS +import XCTest + +class RunnerTests: XCTestCase { + + func testExample() { + // If you add code to the Runner application, consider adding tests here. + // See https://developer.apple.com/documentation/xctest for more information about using XCTest. + } + +} diff --git a/apps/liquid-gen/packages/liquid_flutter/api_guard/api.json b/apps/liquid-gen/packages/liquid_flutter/api_guard/api.json new file mode 100644 index 00000000..2a9baa12 --- /dev/null +++ b/apps/liquid-gen/packages/liquid_flutter/api_guard/api.json @@ -0,0 +1,127776 @@ +[ + { + "filePath": "lib/oss_licenses.dart", + "name": "Package", + "isNullSafe": true, + "description": " Package license definition.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "description", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "homepage", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "repository", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "authors", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "version", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "license", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isMarkdown", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isSdk", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isDirectDependency", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "name", + "type": "String", + "description": " Package name", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "description", + "type": "String", + "description": " Description", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "homepage", + "type": "String?", + "description": " Website URL", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "repository", + "type": "String?", + "description": " Repository URL", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "authors", + "type": "List", + "description": " Authors", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "version", + "type": "String", + "description": " Version", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "license", + "type": "String?", + "description": " License", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isMarkdown", + "type": "bool", + "description": " Whether the license is in markdown format or not (plain text).", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isSdk", + "type": "bool", + "description": " Whether the package is included in the SDK or not.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isDirectDependency", + "type": "bool", + "description": " Whether the package is direct dependency or not.", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/size_reporting_widget.dart", + "name": "SizeReportingWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSizeChange", + "description": "", + "type": "void Function(Size)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSizeChange", + "type": "void Function(Size)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "_SizeReportingWidgetState", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/size_reporting_widget.dart", + "name": "_SizeReportingWidgetState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_oldSize", + "type": "Size?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "SizeReportingWidget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_notifySize", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold.dart", + "name": "LdScaffold", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "body", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "appBars", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "toggleDrawerShortcut", + "description": "", + "type": "SingleActivator?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "extendBodyBehindAppBar", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "backgroundColor", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "drawer", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "drawerWidth", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "304", + "annotations": [] + }, + { + "name": "reflowBreakpoint", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": "900", + "annotations": [] + }, + { + "name": "resizeToAvoidBottomInset", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "searchController", + "description": "", + "type": "TextEditingController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "primaryScrollController", + "description": "", + "type": "ScrollController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "body", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "appBars", + "type": "List?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "backgroundColor", + "type": "Color?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "drawer", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugName", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "resizeToAvoidBottomInset", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "extendBodyBehindAppBar", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "drawerWidth", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "reflowBreakpoint", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "toggleDrawerShortcut", + "type": "SingleActivator?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "searchController", + "type": "TextEditingController?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "primaryScrollController", + "type": "ScrollController?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold.dart", + "name": "LdScaffoldState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_drawerStreamController", + "type": "StreamController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_bodyScrollOffset", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_drawerScrollOffset", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_lastScrollOffset", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_bottomNavigationBarFocusNode", + "type": "FocusNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_focusScopeNode", + "type": "FocusScopeNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_internalScrollController", + "type": "ScrollController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_drawerState", + "type": "LdDrawerState?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "drawerStream", + "type": "Stream", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasDrawer", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "effectiveScrollController", + "type": "ScrollController", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "toggleDrawerShortcut", + "type": "SingleActivator", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_scaffoldDecoration", + "type": "BoxDecoration?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isDrawerOpen", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "bodyScrollOffset", + "type": "ValueNotifier", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdScaffold", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_onDrawerStateChange", + "returnType": "void", + "signature": [ + { + "name": "drawerState", + "description": "", + "type": "LdDrawerState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "scrollToTop", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "maybeOf", + "returnType": "LdScaffoldState?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold.dart", + "name": "ScrollObserver", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "ValueNotifier", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "position", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold.dart", + "name": "LdAppBarScrollBehavior", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "static", + "type": "LdAppBarScrollBehavior", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "mobileOnly", + "type": "LdAppBarScrollBehavior", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "always", + "type": "LdAppBarScrollBehavior", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold.dart", + "name": "LdDrawerSlot", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "drawer", + "type": "LdDrawerSlot", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "body", + "type": "LdDrawerSlot", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold.dart", + "name": "AtLeastEdgeInsets", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "atLeast", + "returnType": "EdgeInsets", + "signature": [ + { + "name": "other", + "description": "", + "type": "EdgeInsets", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "EdgeInsets", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_registry.dart", + "name": "LdAppBarRegistryKey", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "order", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "order", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugName", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_registry.dart", + "name": "AppBarInfo", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "innerHeight", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "verticalMargin", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scrollUnder", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "willHide", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "initial", + "signature": [ + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "position", + "type": "LdAppBarPosition", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "innerHeight", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "verticalMargin", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "offset", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scrollUnder", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "willHide", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "effectiveHeight", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "copyWith", + "returnType": "AppBarInfo", + "signature": [ + { + "name": "position", + "description": "", + "type": "LdAppBarPosition?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "innerHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "willHide", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "verticalMargin", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scrollUnder", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_registry.dart", + "name": "_AppBarRegistryEntryData", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "registryKey", + "description": "", + "type": "LdAppBarRegistryKey", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "child", + "type": "Widget", + "description": " The widget below this widget in the tree.\n\n {@template flutter.widgets.ProxyWidget.child}\n This widget can only have one child. To lay out multiple children, let this\n widget's child be a widget such as [Row], [Column], or [Stack], which have a\n `children` property, and then provide the children to that widget.\n {@endtemplate}", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "registryKey", + "type": "LdAppBarRegistryKey", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "updateShouldNotify", + "returnType": "bool", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_AppBarRegistryEntryData", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "InheritedWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_registry.dart", + "name": "LdAppBarRegistryEntry", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "order", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugName", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "order", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_registry.dart", + "name": "_LdAppBarRegistryEntryState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_key", + "type": "LdAppBarRegistryKey?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_registry", + "type": "AppBarRegistryState", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdAppBarRegistryEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_registry.dart", + "name": "AppBarRegistry", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, List)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "appBars", + "description": "", + "type": "List", + "named": true, + "required": false, + "defaultValue": "const []", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, List)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "appBars", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "maybeStateOf", + "returnType": "AppBarRegistryState?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_registry.dart", + "name": "AppBarRegistryState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_listeners", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_appBarRegistry", + "type": "Map", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_usedOrders", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_parentRegistry", + "type": "AppBarRegistryState?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_parentRegistryListener", + "type": "void Function()?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_bodyPadding", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "bodyPadding", + "type": "ValueNotifier", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "notifyListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "AppBarRegistry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "registerAppBar", + "returnType": "LdAppBarRegistryKey", + "signature": [ + { + "name": "desiredOrder", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Registers an appbar with the desired order.\n If the order is already taken, automatically assigns the next available order.", + "annotations": [] + }, + { + "name": "unregisterAppBar", + "returnType": "void", + "signature": [ + { + "name": "key", + "description": "", + "type": "LdAppBarRegistryKey", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Unregisters an appbar from the registry.", + "annotations": [] + }, + { + "name": "_updateBodyPadding", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "updateAppBarInfo", + "returnType": "void", + "signature": [ + { + "name": "key", + "description": "", + "type": "LdAppBarRegistryKey", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "info", + "description": "", + "type": "AppBarInfo", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called by the AppBarFrame to update the app bar info.", + "annotations": [] + }, + { + "name": "getHigherAppBars", + "returnType": "List", + "signature": [ + { + "name": "key", + "description": "", + "type": "LdAppBarRegistryKey", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "limitToChildrenOf", + "description": "", + "type": "BuildContext?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called by the AppBarFrame to get the cumulative height of the app bars at the given position.", + "annotations": [] + }, + { + "name": "_isDescendantOf", + "returnType": "bool", + "signature": [ + { + "name": "descendant", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "ancestor", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Checks if [descendant] is a descendant of [ancestor] in the widget tree.", + "annotations": [] + }, + { + "name": "getAppBarsAtPosition", + "returnType": "List", + "signature": [ + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "limitToChildrenOf", + "description": "", + "type": "BuildContext?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getLevel", + "returnType": "int", + "signature": [ + { + "name": "appBarKey", + "description": "", + "type": "LdAppBarRegistryKey", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "limitToChildrenOf", + "description": "", + "type": "BuildContext?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the level of an appbar at the given position.\n The level considers:\n - Parent registries that have appbars at the same position\n - Appbars in the current registry at the same position that come before this appbar", + "annotations": [] + }, + { + "name": "getAllAppBarsAtPosition", + "returnType": "List", + "signature": [ + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "limitToChildrenOf", + "description": "", + "type": "BuildContext?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getTotalHeightAtPosition", + "returnType": "double", + "signature": [ + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "limitToChildrenOf", + "description": "", + "type": "BuildContext?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getEffectiveHeightOfOthers", + "returnType": "double", + "signature": [ + { + "name": "key", + "description": "", + "type": "LdAppBarRegistryKey", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "limitToChildrenOf", + "description": "", + "type": "BuildContext?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getCumulativeHeightForPosition", + "returnType": "double", + "signature": [ + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "excludeKey", + "description": "", + "type": "LdAppBarRegistryKey", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getAppBarInfo", + "returnType": "AppBarInfo?", + "signature": [ + { + "name": "key", + "description": "", + "type": "LdAppBarRegistryKey", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Get the current AppBarInfo for a given key", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "ChangeNotifyingState", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_registry.dart", + "name": "ChangeNotifyingState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_listeners", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Describes the part of the user interface represented by this widget.\n\n The framework calls this method in a number of different situations. For\n example:\n\n * After calling [initState].\n * After calling [didUpdateWidget].\n * After receiving a call to [setState].\n * After a dependency of this [State] object changes (e.g., an\n [InheritedWidget] referenced by the previous [build] changes).\n * After calling [deactivate] and then reinserting the [State] object into\n the tree at another location.\n\n This method can potentially be called in every frame and should not have\n any side effects beyond building a widget.\n\n The framework replaces the subtree below this widget with the widget\n returned by this method, either by updating the existing subtree or by\n removing the subtree and inflating a new subtree, depending on whether the\n widget returned by this method can update the root of the existing\n subtree, as determined by calling [Widget.canUpdate].\n\n Typically implementations return a newly created constellation of widgets\n that are configured with information from this widget's constructor, the\n given [BuildContext], and the internal state of this [State] object.\n\n The given [BuildContext] contains information about the location in the\n tree at which this widget is being built. For example, the context\n provides the set of inherited widgets for this location in the tree. The\n [BuildContext] argument is always the same as the [context] property of\n this [State] object and will remain the same for the lifetime of this\n object. The [BuildContext] argument is provided redundantly here so that\n this method matches the signature for a [WidgetBuilder].\n\n ## Design discussion\n\n ### Why is the [build] method on [State], and not [StatefulWidget]?\n\n Putting a `Widget build(BuildContext context)` method on [State] rather\n than putting a `Widget build(BuildContext context, State state)` method\n on [StatefulWidget] gives developers more flexibility when subclassing\n [StatefulWidget].\n\n For example, [AnimatedWidget] is a subclass of [StatefulWidget] that\n introduces an abstract `Widget build(BuildContext context)` method for its\n subclasses to implement. If [StatefulWidget] already had a [build] method\n that took a [State] argument, [AnimatedWidget] would be forced to provide\n its [State] object to subclasses even though its [State] object is an\n internal implementation detail of [AnimatedWidget].\n\n Conceptually, [StatelessWidget] could also be implemented as a subclass of\n [StatefulWidget] in a similar manner. If the [build] method were on\n [StatefulWidget] rather than [State], that would not be possible anymore.\n\n Putting the [build] function on [State] rather than [StatefulWidget] also\n helps avoid a category of bugs related to closures implicitly capturing\n `this`. If you defined a closure in a [build] function on a\n [StatefulWidget], that closure would implicitly capture `this`, which is\n the current widget instance, and would have the (immutable) fields of that\n instance in scope:\n\n ```dart\n // (this is not valid Flutter code)\n class MyButton extends StatefulWidgetX {\n MyButton({super.key, required this.color});\n\n final Color color;\n\n @override\n Widget build(BuildContext context, State state) {\n return SpecialWidget(\n handler: () { print('color: $color'); },\n );\n }\n }\n ```\n\n For example, suppose the parent builds `MyButton` with `color` being blue,\n the `$color` in the print function refers to blue, as expected. Now,\n suppose the parent rebuilds `MyButton` with green. The closure created by\n the first build still implicitly refers to the original widget and the\n `$color` still prints blue even through the widget has been updated to\n green; should that closure outlive its widget, it would print outdated\n information.\n\n In contrast, with the [build] function on the [State] object, closures\n created during [build] implicitly capture the [State] instance instead of\n the widget instance:\n\n ```dart\n class MyButton extends StatefulWidget {\n const MyButton({super.key, this.color = Colors.teal});\n\n final Color color;\n // ...\n }\n\n class MyButtonState extends State {\n // ...\n @override\n Widget build(BuildContext context) {\n return SpecialWidget(\n handler: () { print('color: ${widget.color}'); },\n );\n }\n }\n ```\n\n Now when the parent rebuilds `MyButton` with green, the closure created by\n the first build still refers to [State] object, which is preserved across\n rebuilds, but the framework has updated that [State] object's [widget]\n property to refer to the new `MyButton` instance and `${widget.color}`\n prints green, as expected.\n\n See also:\n\n * [StatefulWidget], which contains the discussion on performance considerations.", + "annotations": [ + "@protected" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "notifyListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [ + "Listenable" + ], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_registry.dart", + "name": "AppBarRegistryEntryExtension", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "maybeAppBarRegistryKey", + "returnType": "LdAppBarRegistryKey?", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "appBarRegistryKey", + "returnType": "LdAppBarRegistryKey", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "BuildContext", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/tab_navigation.dart", + "name": "LdNavigationTab", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "label", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "route", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isActive", + "description": "", + "type": "bool Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "label", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "route", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isActive", + "type": "bool Function(BuildContext)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/tab_navigation.dart", + "name": "LdTabNavigation", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "activeRoute", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "tabs", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onTabPressed", + "description": "", + "type": "void Function(String)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "addContainer", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "enableGradient", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "attachedMode", + "description": "", + "type": "LdAppBarAttachedMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarAttachedMode.adaptive", + "annotations": [] + }, + { + "name": "backgroundMode", + "description": "", + "type": "LdAppBarBackgroundMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarBackgroundMode.adaptive", + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "LdAppBarPositionMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarPositionMode.adaptive", + "annotations": [] + }, + { + "name": "scrollBehavior", + "description": "", + "type": "LdAppBarScrollBehavior", + "named": true, + "required": false, + "defaultValue": "LdAppBarScrollBehavior.static", + "annotations": [] + }, + { + "name": "order", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "maxVisibleTabs", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "5", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "activeRoute", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onTabPressed", + "type": "void Function(String)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "tabs", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "attachedMode", + "type": "LdAppBarAttachedMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "backgroundMode", + "type": "LdAppBarBackgroundMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "position", + "type": "LdAppBarPositionMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scrollBehavior", + "type": "LdAppBarScrollBehavior", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "addContainer", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "order", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "enableGradient", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxVisibleTabs", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/tab_navigation.dart", + "name": "_LdTabNavigationState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_focusNode", + "type": "FocusNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_moreMenuKey", + "type": "GlobalKey", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_indicatorPosition", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_navWidth", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragStartPosition", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_lastDraggedTabIndex", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragStartIndicatorPosition", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragging", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_effectivePosition", + "type": "LdAppBarPosition", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_visibleTabs", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tabWidth", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_showingMore", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdTabNavigation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_effectivelyAttached", + "returnType": "bool", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_activeIndex", + "returnType": "int", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateIndicatorPosition", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getClosestTab", + "returnType": "int", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onIndicatorDragEnd", + "returnType": "void", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragEndDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onIndicatorDragUpdate", + "returnType": "void", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragUpdateDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onTabTap", + "returnType": "void", + "signature": [ + { + "name": "route", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_fillOpacity", + "returnType": "int", + "signature": [ + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_fillColor", + "returnType": "Color", + "signature": [ + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildOutsideDecoration", + "returnType": "BoxDecoration", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isAttached", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildInsideDecoration", + "returnType": "BoxDecoration", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isAttached", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/macos_window_controls.dart", + "name": "MacOSWindowControls", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/windows_window_controls.dart", + "name": "WindowsWindowControls", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_action_overflow_menu.dart", + "name": "LdAppbarActionOverflowMenu", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "actions", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inMenu", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "menuProviders", + "description": "", + "type": "List Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "actions", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "menuProviders", + "type": "List Function(BuildContext)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "inMenu", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/bottom_bar.dart", + "name": "LdBottomBar", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/search_config.dart", + "name": "LdSearchConfig", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "getSuggestions", + "description": "", + "type": "Future> Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildSuggestion", + "description": "", + "type": "Widget Function(BuildContext, dynamic)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSearch", + "description": "", + "type": "void Function(String)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inputFocusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hint", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialQuery", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "getSuggestions", + "type": "Future> Function(String)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "buildSuggestion", + "type": "Widget Function(BuildContext, dynamic)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSearch", + "type": "void Function(String)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hint", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialQuery", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_action.dart", + "name": "LdAppBarAction", + "isNullSafe": true, + "description": " An action button designed for use in app bars that adapts its appearance based on context.\n\n This widget automatically detects whether it's being rendered in the main app bar or in\n an overflow menu (context menu) and adjusts its appearance accordingly:\n\n - **In the app bar**: Renders as a [LdButton] with the provided [child], [leading],\n and [trailing] widgets. On mobile devices, if [preferLeadingOnMobile] is true and a\n [leading] widget is provided, the leading icon replaces the child text to save space.\n\n - **In the overflow menu**: Renders as a [LdListItem] with a more compact list item\n appearance. The leading widget (if provided) is wrapped in an [LdAvatar], and the\n [child] becomes the list item title. If [loading] is true, a loading indicator\n is shown in the avatar, and [loadingText] (if provided) appears as the subtitle.\n\n Actions that overflow from the app bar are automatically moved to the overflow menu\n by the app bar's overflow handling system.\n\n See also:\n - [LdAppBar] for the app bar that hosts these actions", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "tooltip", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "preferLeadingOnMobile", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buttonMode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "tooltip", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "FutureOr Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "preferLeadingOnMobile", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "buttonMode", + "type": "LdButtonMode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingText", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loading", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_scroll_wrapper.dart", + "name": "LdAppBarScrollWrapper", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scrollBehavior", + "description": "", + "type": "LdAppBarScrollBehavior", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "position", + "type": "LdAppBarPosition", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scrollBehavior", + "type": "LdAppBarScrollBehavior", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_scroll_wrapper.dart", + "name": "LdAppBarScrollWrapperState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_lastScrollOffset", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_scrollOffsetNotifier", + "type": "ValueNotifier?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_registryState", + "type": "AppBarRegistryState?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_registryListener", + "type": "void Function()?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_registryKey", + "type": "LdAppBarRegistryKey?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdAppBarScrollWrapper", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_handleScrollOffsetChange", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateAppBarOffset", + "returnType": "void", + "signature": [ + { + "name": "scrollOffset", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "currentInfo", + "description": "", + "type": "AppBarInfo", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scrolledUnder", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_shouldHideAppBar", + "returnType": "bool", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_scroll_wrapper.dart", + "name": "LdAppBarPosition", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "top", + "type": "LdAppBarPosition", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "bottom", + "type": "LdAppBarPosition", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/search_components.dart", + "name": "LdSearchInput", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "searchConfig", + "description": "", + "type": "LdSearchConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fullWidth", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "isBottomNavigationBar", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "searchConfig", + "type": "LdSearchConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "fullWidth", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isBottomNavigationBar", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/search_components.dart", + "name": "_LdSearchInputState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_inputKey", + "type": "GlobalKey>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_inputWrapperFocusNode", + "type": "FocusScopeNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_suggestionsFocusNode", + "type": "FocusScopeNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_inputController", + "type": "TextEditingController", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_overlayEntry", + "type": "OverlayEntry?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_inputRectNotifier", + "type": "ValueNotifier", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_intentSubscription", + "type": "StreamSubscription?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdSearchInput", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_onFocusChanged", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateInputRect", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_showSuggestionsOverlay", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_showOverlay", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_closeOverlay", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onSuggestionAccepted", + "returnType": "void", + "signature": [ + { + "name": "suggestion", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onKeyEvent", + "returnType": "KeyEventResult", + "signature": [ + { + "name": "node", + "description": "", + "type": "FocusNode", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "event", + "description": "", + "type": "KeyEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/search_components.dart", + "name": "LdSearchSuggestionsOverlay", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "searchConfig", + "description": "", + "type": "LdSearchConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inputRectNotifier", + "description": "", + "type": "ValueNotifier", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isBottomNavigationBar", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onDismiss", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "suggestionsFocusNode", + "description": "", + "type": "FocusScopeNode", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSuggestionAccepted", + "description": "", + "type": "void Function(String)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inputController", + "description": "", + "type": "TextEditingController", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "searchConfig", + "type": "LdSearchConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "inputRectNotifier", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isBottomNavigationBar", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onDismiss", + "type": "void Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "suggestionsFocusNode", + "type": "FocusScopeNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSuggestionAccepted", + "type": "void Function(String)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "inputController", + "type": "TextEditingController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/search_components.dart", + "name": "_LdSearchSuggestionsOverlayState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickers", + "type": "Set?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickerModeNotifier", + "type": "ValueListenable?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_fadeController", + "type": "AnimationController", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_fadeAnimation", + "type": "Animation", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_debounceTimer", + "type": "Timer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_currentQuery", + "type": "String", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdSearchSuggestionsOverlay", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "createTicker", + "returnType": "Ticker", + "signature": [ + { + "name": "onTick", + "description": "", + "type": "void Function(Duration)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Creates a ticker with the given callback.\n\n The kind of ticker provided depends on the kind of ticker provider.", + "annotations": [ + "@factory" + ] + }, + { + "name": "_removeTicker", + "returnType": "void", + "signature": [ + { + "name": "ticker", + "description": "", + "type": "_WidgetTicker", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickers", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickerModeNotifier", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onTextChanged", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onInputRectChanged", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_close", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_placeOverlay", + "returnType": "Widget", + "signature": [ + { + "name": "screenSize", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inputRect", + "description": "", + "type": "Rect", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildSuggestionsContent", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "TickerProviderStateMixin" + ] + }, + { + "filePath": "lib/src/appbar/search_components.dart", + "name": "LdSearchAcceptSuggestion", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "suggestion", + "description": "", + "type": "dynamic", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "suggestion", + "type": "dynamic", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "dispatch", + "returnType": "void", + "signature": [ + { + "name": "target", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Start bubbling this notification at the given build context.\n\n The notification will be delivered to any [NotificationListener] widgets\n with the appropriate type parameters that are ancestors of the given\n [BuildContext]. If the [BuildContext] is null, the notification is not\n dispatched.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugFillDescription", + "returnType": "void", + "signature": [ + { + "name": "description", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional information to the given description for use by [toString].\n\n This method makes it easier for subclasses to coordinate to provide a\n high-quality [toString] implementation. The [toString] implementation on\n the [Notification] base class calls [debugFillDescription] to collect\n useful information from subclasses to incorporate into its return value.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.debugFillDescription(description)`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Notification", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/drawer_buttons.dart", + "name": "OpenDrawerButton", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "drawerParent", + "description": "", + "type": "LdScaffoldState?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "drawerParent", + "type": "LdScaffoldState?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_shouldShow", + "returnType": "bool", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/drawer_buttons.dart", + "name": "CloseDrawerButton", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_shouldShow", + "returnType": "bool", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/window_callbacks.dart", + "name": "LdWindowCallbacks", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "onClose", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onMinimize", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onMaximize", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onMove", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "onClose", + "type": "void Function()?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onMinimize", + "type": "void Function()?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onMaximize", + "type": "void Function()?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onMove", + "type": "void Function()?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "LdAppBar", + "isNullSafe": true, + "description": " A flexible app bar widget that can be positioned at the top or bottom of a scaffold.\n\n ## Adding App Bars to Scaffolds\n\n App bars are added to a scaffold by passing them in the `appBars` parameter of [LdScaffold]:\n\n ```dart\n LdScaffold(\n appBars: [\n LdAppBar.top(title: Text('My App')),\n LdAppBar.bottom(actions: [/* ... */]),\n ],\n body: MyContent(),\n )\n ```\n\n Multiple app bars can be added to a single scaffold, and they will be stacked\n vertically based on their position and order.\n\n ## Utility Constructors and Positioning\n\n Use the utility constructors to specify the app bar's position:\n\n - [LdAppBar.top] - Places the app bar at the top of the scaffold\n - [LdAppBar.bottom] - Places the app bar at the bottom of the scaffold\n - [LdAppBar] (default) - Uses [positionMode] to determine position (defaults to top)\n\n The [order] parameter controls the stacking order when multiple app bars are at the same\n position. Lower order values appear closer to the content (higher in the visual stack).\n For example, an app bar with `order: 0` will be positioned above an app bar with `order: 1`\n when both are at the top position.\n\n ## MediaQuery Padding\n\n The app bar's size is automatically applied to the scaffold body's [MediaQuery] padding.\n This ensures that content in the body is not obscured by the app bar. The padding is\n calculated based on the app bar's effective height (including margins) and is updated\n dynamically as app bars are added, removed, or resized.\n\n The padding is applied separately for top and bottom app bars:\n - Top app bars add padding to `MediaQuery.padding.top`\n - Bottom app bars add padding to `MediaQuery.padding.bottom`\n\n ## Actions and Overflow Menu\n\n Actions provided in the [actions] list are displayed in the app bar. When there isn't\n enough space to display all actions, they automatically overflow into a menu accessible\n via an ellipsis button. The overflow menu is implemented using [LdAppbarActionOverflowMenu].\n\n ## Action Behavior in Different Contexts\n\n [LdAppBarAction] widgets behave differently depending on their context:\n\n - **In the app bar**: Actions are rendered as [LdButton] widgets with optional leading/trailing\n icons. On mobile, if [preferLeadingOnMobile] is true, the leading icon replaces the child\n text to save space.\n\n - **In the overflow menu**: Actions are rendered as [LdListItem] widgets with a more compact\n list item appearance. The action automatically detects when it's inside a context menu\n (overflow menu) and switches to this presentation.\n\n This dual behavior allows actions to have an appropriate appearance whether they're visible\n in the main app bar or hidden in the overflow menu.\n\n See also:\n - [LdAppBarAction] for creating action buttons\n - [LdScaffold] for the scaffold that hosts app bars\n - [AppBarRegistry] for the internal registry that manages app bar positioning", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "actions", + "description": "", + "type": "List", + "named": true, + "required": false, + "defaultValue": "const []", + "annotations": [] + }, + { + "name": "addContainer", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "attachedMode", + "description": "", + "type": "LdAppBarAttachedMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarAttachedMode.adaptive", + "annotations": [] + }, + { + "name": "autoAttachToKeyboard", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "backgroundColor", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "backgroundMode", + "description": "", + "type": "LdAppBarBackgroundMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarBackgroundMode.adaptive", + "annotations": [] + }, + { + "name": "borderMode", + "description": "", + "type": "LdAppBarBorderMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarBorderMode.adaptive", + "annotations": [] + }, + { + "name": "bottom", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "implyCloseModalButton", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "implyLeading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "avoidViewInsets", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "order", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "overflowMenuProviders", + "description": "", + "type": "List Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "positionMode", + "description": "", + "type": "LdAppBarPositionMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarPositionMode.top", + "annotations": [] + }, + { + "name": "scrollBehavior", + "description": "", + "type": "LdAppBarScrollBehavior", + "named": true, + "required": false, + "defaultValue": "LdAppBarScrollBehavior.static", + "annotations": [] + }, + { + "name": "searchConfig", + "description": "", + "type": "LdSearchConfig?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "shadowMode", + "description": "", + "type": "LdAppBarShadowMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarShadowMode.adaptive", + "annotations": [] + }, + { + "name": "showWindowControls", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "top", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "actions", + "description": "", + "type": "List", + "named": true, + "required": false, + "defaultValue": "const []", + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoAttachToKeyboard", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "avoidViewInsets", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "showWindowControls", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "backgroundColor", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "searchConfig", + "description": "", + "type": "LdSearchConfig?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "addContainer", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "implyCloseModalButton", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "implyLeading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "bottom", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "attachedMode", + "description": "", + "type": "LdAppBarAttachedMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarAttachedMode.adaptive", + "annotations": [] + }, + { + "name": "shadowMode", + "description": "", + "type": "LdAppBarShadowMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarShadowMode.adaptive", + "annotations": [] + }, + { + "name": "borderMode", + "description": "", + "type": "LdAppBarBorderMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarBorderMode.adaptive", + "annotations": [] + }, + { + "name": "backgroundMode", + "description": "", + "type": "LdAppBarBackgroundMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarBackgroundMode.adaptive", + "annotations": [] + }, + { + "name": "overflowMenuProviders", + "description": "", + "type": "List Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scrollBehavior", + "description": "", + "type": "LdAppBarScrollBehavior", + "named": true, + "required": false, + "defaultValue": "LdAppBarScrollBehavior.static", + "annotations": [] + }, + { + "name": "order", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "bottom", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "actions", + "description": "", + "type": "List", + "named": true, + "required": false, + "defaultValue": "const []", + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "addContainer", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "showWindowControls", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "avoidViewInsets", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "attachedMode", + "description": "", + "type": "LdAppBarAttachedMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarAttachedMode.adaptive", + "annotations": [] + }, + { + "name": "autoAttachToKeyboard", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "backgroundColor", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "searchConfig", + "description": "", + "type": "LdSearchConfig?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "implyCloseModalButton", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "implyLeading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "bottom", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "shadowMode", + "description": "", + "type": "LdAppBarShadowMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarShadowMode.adaptive", + "annotations": [] + }, + { + "name": "borderMode", + "description": "", + "type": "LdAppBarBorderMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarBorderMode.adaptive", + "annotations": [] + }, + { + "name": "backgroundMode", + "description": "", + "type": "LdAppBarBackgroundMode", + "named": true, + "required": false, + "defaultValue": "LdAppBarBackgroundMode.adaptive", + "annotations": [] + }, + { + "name": "overflowMenuProviders", + "description": "", + "type": "List Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scrollBehavior", + "description": "", + "type": "LdAppBarScrollBehavior", + "named": true, + "required": false, + "defaultValue": "LdAppBarScrollBehavior.static", + "annotations": [] + }, + { + "name": "order", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "title", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "backgroundColor", + "type": "Color?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "implyLeading", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "addContainer", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "bottom", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shadowMode", + "type": "LdAppBarShadowMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderMode", + "type": "LdAppBarBorderMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "backgroundMode", + "type": "LdAppBarBackgroundMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "attachedMode", + "type": "LdAppBarAttachedMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "showWindowControls", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "implyCloseModalButton", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "avoidViewInsets", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoAttachToKeyboard", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "actions", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "callbacks", + "type": "LdWindowCallbacks?", + "description": "", + "features": [ + "static" + ], + "annotations": [] + }, + { + "name": "overflowMenuProviders", + "type": "List Function(BuildContext)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "searchConfig", + "type": "LdSearchConfig?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugName", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "positionMode", + "type": "LdAppBarPositionMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scrollBehavior", + "type": "LdAppBarScrollBehavior", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "order", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "_LdAppBarState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdAppBar", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "_LdAppBarInner", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "appBar", + "description": "", + "type": "LdAppBar", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "appBar", + "type": "LdAppBar", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_LdAppBarInner>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "_LdAppBarInnerState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_focusScopeNode", + "type": "FocusScopeNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_isModal", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_canDismissModal", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_canPopParentRoute", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_drawerSlot", + "type": "LdDrawerSlot?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isDrawer", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_effectivePosition", + "type": "LdAppBarPosition", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_showWindowsWindowControls", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_headerStyle", + "type": "TextStyle", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isInTopSlot", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isInBottomSlot", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isSurface", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_hasTopContent", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_systemUiOverlayStyle", + "type": "SystemUiOverlayStyle", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_LdAppBarInner", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_handleFocusChange", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_handleAppBarRegistryChange", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_closeModalButton", + "returnType": "Widget?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_level", + "returnType": "int", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_effectivelyAttached", + "returnType": "bool", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_findDrawerParent", + "returnType": "LdScaffoldState?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildLeading", + "returnType": "Widget?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_shouldShowShadow", + "returnType": "bool", + "signature": [ + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_shouldShowBorder", + "returnType": "bool", + "signature": [ + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildOutsideDecoration", + "returnType": "BoxDecoration", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isAttached", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Wraps the app bar in a container that applies the correct padding to make sure\n the app bar is not covered by the system UI or parent app bars.", + "annotations": [] + }, + { + "name": "_fillOpacity", + "returnType": "int", + "signature": [ + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_fillColor", + "returnType": "Color", + "signature": [ + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_borderRadius", + "returnType": "double", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildInsideDecoration", + "returnType": "BoxDecoration", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isScrolledUnder", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isAttached", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "ScrolledUnderBuilder", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, bool)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, bool)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "_ScrolledUnderBuilderState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isScrolledUnder", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_registry", + "type": "AppBarRegistryState?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "appBarKey", + "type": "LdAppBarRegistryKey", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "ScrolledUnderBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_onRegistryChange", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "LdAppBarShadowMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "visible", + "type": "LdAppBarShadowMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "whenScrolled", + "type": "LdAppBarShadowMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "hidden", + "type": "LdAppBarShadowMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "adaptive", + "type": "LdAppBarShadowMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "LdAppBarBorderMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "visible", + "type": "LdAppBarBorderMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "whenScrolled", + "type": "LdAppBarBorderMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "hidden", + "type": "LdAppBarBorderMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "adaptive", + "type": "LdAppBarBorderMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "LdAppBarBackgroundMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "visible", + "type": "LdAppBarBackgroundMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "whenScrolled", + "type": "LdAppBarBackgroundMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "hidden", + "type": "LdAppBarBackgroundMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "adaptive", + "type": "LdAppBarBackgroundMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "LdAppBarPositionMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "top", + "type": "LdAppBarPositionMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "bottom", + "type": "LdAppBarPositionMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "adaptive", + "type": "LdAppBarPositionMode", + "description": " Will move to the bottom slot on mobile.", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "LdAppBarAttachedMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "attached", + "type": "LdAppBarAttachedMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "adaptive", + "type": "LdAppBarAttachedMode", + "description": " The app bar is floating when in the bottom slot on mobile.", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "floating", + "type": "LdAppBarAttachedMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "AtLeastBorderRadius", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "atLeast", + "returnType": "BorderRadius", + "signature": [ + { + "name": "other", + "description": "", + "type": "BorderRadius", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "BorderRadius", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "AtLeast", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "atLeast", + "returnType": "Radius", + "signature": [ + { + "name": "other", + "description": "", + "type": "Radius", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "Radius", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar.dart", + "name": "TrimToAppBarPosition", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "trimToAppBarPosition", + "returnType": "EdgeInsets", + "signature": [ + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "EdgeInsets", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_frame.dart", + "name": "AppBarFrame", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "attached", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "addContainer", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "insideDecoration", + "description": "", + "type": "BoxDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "outsideDecoration", + "description": "", + "type": "BoxDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "avoidViewInsets", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "insetBorderRadius", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "insidePadding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "outsideMinPadding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "position", + "type": "LdAppBarPosition", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "insideDecoration", + "type": "BoxDecoration?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "outsideDecoration", + "type": "BoxDecoration?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "insidePadding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "outsideMinPadding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "addContainer", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "insetBorderRadius", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "avoidViewInsets", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugName", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "attached", + "type": "bool", + "description": " Whether the appbar is attached to the scaffold or floating.\n A floating appbar has some margin on the outside and padding on the inside.\n An attached appbar has no margin on the outside and padding on the inside.", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/appbar/appbar_frame.dart", + "name": "_AppBarFrameState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_focusScopeNode", + "type": "FocusScopeNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_registry", + "type": "AppBarRegistryState", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_previousOutsidePadding", + "type": "EdgeInsets", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "AppBarFrame", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_setInitialPosition", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onRegistryChange", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getKey", + "returnType": "LdAppBarRegistryKey?", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_calculateOtherAppBarHeight", + "returnType": "double", + "signature": [ + { + "name": "position", + "description": "", + "type": "LdAppBarPosition", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_calculateLevel", + "returnType": "int", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_containerPadding", + "returnType": "EdgeInsets", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_outsideContainerPadding", + "returnType": "EdgeInsets", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_insidePadding", + "returnType": "EdgeInsets", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onSizeChange", + "returnType": "void", + "signature": [ + { + "name": "size", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateMargin", + "returnType": "void", + "signature": [ + { + "name": "outsidePadding", + "description": "", + "type": "EdgeInsets", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/tokens.dart", + "name": "LdSize", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "xs", + "type": "LdSize", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "s", + "type": "LdSize", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "m", + "type": "LdSize", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "l", + "type": "LdSize", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/tokens.dart", + "name": "Modifier", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "adjust", + "returnType": "LdSize", + "signature": [ + { + "name": "steps", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "clamp", + "returnType": "LdSize", + "signature": [ + { + "name": "min", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "max", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "LdSize", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/tokens.dart", + "name": "LdRadius", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "radius", + "returnType": "BorderRadius", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "LdSize", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/drawer/section_item.dart", + "name": "LdDrawerItemSection", + "isNullSafe": true, + "description": " A section in the drawer that can contain a collapsable sub-items", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initiallyExpanded", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "dynamic Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "children", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initiallyExpanded", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "children", + "type": "List?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "dynamic Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/drawer/section_item.dart", + "name": "_LdDrawerItemSectionState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_expanded", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_theme", + "type": "LdTheme", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_trailingItem", + "type": "Widget", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isExpanded", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdDrawerItemSection", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_leading", + "returnType": "Widget", + "signature": [ + { + "name": "color", + "description": "", + "type": "Color", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onTap", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "buildItem", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/drawer/section_header.dart", + "name": "LdSectionHeader", + "isNullSafe": true, + "description": " A title for a section in the drawer", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "text", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/drawer_state.dart", + "name": "LdDrawerState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "isOpen", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isSideBySide", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "isOpen", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isSideBySide", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/intersperse.dart", + "name": "IntersperseIterable", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "intersperse", + "returnType": "Iterable", + "signature": [ + { + "name": "element", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "Iterable", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/intersperse.dart", + "name": "intersperseIterable", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "intersperseIterable", + "returnType": "Iterable", + "signature": [ + { + "name": "element", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "iterable", + "description": "", + "type": "Iterable", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/l10n/generated/liquid_localizations.dart", + "name": "LiquidLocalizations", + "isNullSafe": true, + "description": " Callers can lookup localized strings with an instance of LiquidLocalizations\n returned by `LiquidLocalizations.of(context)`.\n\n Applications need to include `LiquidLocalizations.delegate()` in their app's\n `localizationDelegates` list, and the locales they support in the app's\n `supportedLocales` list. For example:\n\n ```dart\n import 'generated/liquid_localizations.dart';\n\n return MaterialApp(\n localizationsDelegates: LiquidLocalizations.localizationsDelegates,\n supportedLocales: LiquidLocalizations.supportedLocales,\n home: MyApplicationHome(),\n );\n ```\n\n ## Update pubspec.yaml\n\n Please make sure to update your pubspec.yaml to include the following\n packages:\n\n ```yaml\n dependencies:\n # Internationalization support.\n flutter_localizations:\n sdk: flutter\n intl: any # Use the pinned version from flutter_localizations\n\n # Rest of dependencies\n ```\n\n ## iOS Applications\n\n iOS applications define key application metadata, including supported\n locales, in an Info.plist file that is built into the application bundle.\n To configure the locales supported by your app, you’ll need to edit this\n file.\n\n First, open your project’s ios/Runner.xcworkspace Xcode workspace file.\n Then, in the Project Navigator, open the Info.plist file under the Runner\n project’s Runner folder.\n\n Next, select the Information Property List item, select Add Item from the\n Editor menu, then select Localizations from the pop-up menu.\n\n Select and expand the newly-created Localizations item then, for each\n locale your application supports, add a new item and select the locale\n you wish to add from the pop-up menu in the Value field. This list should\n be consistent with the languages listed in the LiquidLocalizations.supportedLocales\n property.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "locale", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "localeName", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "delegate", + "type": "LocalizationsDelegate", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "localizationsDelegates", + "type": "List>", + "description": " A list of this localizations delegate along with the default localizations\n delegates.\n\n Returns a list of localizations delegates containing this delegate along with\n GlobalMaterialLocalizations.delegate, GlobalCupertinoLocalizations.delegate,\n and GlobalWidgetsLocalizations.delegate.\n\n Additional delegates can be added by appending to this list in\n MaterialApp. This list does not have to be used at all if a custom list\n of delegates is preferred or required.", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "supportedLocales", + "type": "List", + "description": " A list of this localizations delegate's supported locales.", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "searchAgain", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "search", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "noItemsFound", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "cancel", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "confirm", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "ok", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "done", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "enterText", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "refresh", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "errorOccurred", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "failed", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "retry", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "choose", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "submit", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectDate", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectTime", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "unknownError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "moreInfo", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "close", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "clearError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "loading", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "networkError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "timeoutError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "formatError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "createNew", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "delete", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "deleteSelected", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "edit", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "select", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "filter", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "apply", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "activeFilters", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sort", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "minimize", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "maximize", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hideDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "clearSelection", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "openDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "closeDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "ctrlListExplanation", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "listHidden", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "shiftListExplanation", + "type": "String", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "of", + "returnType": "LiquidLocalizations", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "retryIn", + "returnType": "String", + "signature": [ + { + "name": "seconds", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " No description provided for @retryIn.\n\n In en, this message translates to:\n **'Retry in {seconds}s...'**", + "annotations": [] + }, + { + "name": "deleteNItems", + "returnType": "String", + "signature": [ + { + "name": "items", + "description": "", + "type": "num", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " No description provided for @deleteNItems.\n\n In en, this message translates to:\n **'Delete {items} {items,plural, =1{item}other{items}}'**", + "annotations": [] + }, + { + "name": "clearSelectionBody", + "returnType": "String", + "signature": [ + { + "name": "n", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " No description provided for @clearSelectionBody.\n\n In en, this message translates to:\n **'Are you sure you want to discard your selection of {n} items?'**", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/l10n/generated/liquid_localizations.dart", + "name": "_LiquidLocalizationsDelegate", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "type", + "type": "Type", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "isSupported", + "returnType": "bool", + "signature": [ + { + "name": "locale", + "description": "", + "type": "Locale", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "load", + "returnType": "Future", + "signature": [ + { + "name": "locale", + "description": "", + "type": "Locale", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "shouldReload", + "returnType": "bool", + "signature": [ + { + "name": "old", + "description": "", + "type": "_LiquidLocalizationsDelegate", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LocalizationsDelegate", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/l10n/generated/liquid_localizations.dart", + "name": "lookupLiquidLocalizations", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "lookupLiquidLocalizations", + "returnType": "LiquidLocalizations", + "signature": [ + { + "name": "locale", + "description": "", + "type": "Locale", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/l10n/generated/liquid_localizations_de.dart", + "name": "LiquidLocalizationsDe", + "isNullSafe": true, + "description": " The translations for German (`de`).", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "locale", + "description": "", + "type": "String", + "named": false, + "required": false, + "defaultValue": "'de'", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "localeName", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "searchAgain", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "search", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "noItemsFound", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "cancel", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "confirm", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "ok", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "done", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "enterText", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "refresh", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "errorOccurred", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "failed", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "retry", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "choose", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "submit", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectDate", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectTime", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "unknownError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "moreInfo", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "close", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "clearError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "loading", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "networkError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "timeoutError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "formatError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "createNew", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "delete", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "deleteSelected", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "edit", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "select", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "filter", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "apply", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "activeFilters", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sort", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "minimize", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "maximize", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hideDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "clearSelection", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "openDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "closeDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "ctrlListExplanation", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "listHidden", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "shiftListExplanation", + "type": "String", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "retryIn", + "returnType": "String", + "signature": [ + { + "name": "seconds", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "deleteNItems", + "returnType": "String", + "signature": [ + { + "name": "items", + "description": "", + "type": "num", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "clearSelectionBody", + "returnType": "String", + "signature": [ + { + "name": "n", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LiquidLocalizations", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/l10n/generated/liquid_localizations_en.dart", + "name": "LiquidLocalizationsEn", + "isNullSafe": true, + "description": " The translations for English (`en`).", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "locale", + "description": "", + "type": "String", + "named": false, + "required": false, + "defaultValue": "'en'", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "localeName", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "searchAgain", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "search", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "noItemsFound", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "cancel", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "confirm", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "ok", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "done", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "enterText", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "refresh", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "errorOccurred", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "failed", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "retry", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "choose", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "submit", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectDate", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectTime", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "unknownError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "moreInfo", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "close", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "clearError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "loading", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "networkError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "timeoutError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "formatError", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "createNew", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "delete", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "deleteSelected", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "edit", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "select", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "filter", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "apply", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "activeFilters", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sort", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "minimize", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "maximize", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hideDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "clearSelection", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "openDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "closeDrawer", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "ctrlListExplanation", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "listHidden", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "shiftListExplanation", + "type": "String", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "retryIn", + "returnType": "String", + "signature": [ + { + "name": "seconds", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "deleteNItems", + "returnType": "String", + "signature": [ + { + "name": "items", + "description": "", + "type": "num", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "clearSelectionBody", + "returnType": "String", + "signature": [ + { + "name": "n", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LiquidLocalizations", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/device_info.dart", + "name": "DeviceInfo", + "isNullSafe": true, + "description": " Provides device type detection functionality across all platforms", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "isMobile", + "type": "bool", + "description": "", + "features": [ + "static" + ], + "annotations": [] + }, + { + "name": "isPhone", + "type": "bool", + "description": "", + "features": [ + "static" + ], + "annotations": [] + }, + { + "name": "isTablet", + "type": "bool", + "description": "", + "features": [ + "static" + ], + "annotations": [] + }, + { + "name": "isDesktop", + "type": "bool", + "description": "", + "features": [ + "static" + ], + "annotations": [] + }, + { + "name": "isWeb", + "type": "bool", + "description": "", + "features": [ + "static" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "getDeviceType", + "returnType": "DeviceType", + "signature": [], + "features": [ + "static" + ], + "description": " Detects the current device type\n\n Returns a [DeviceType] enum value representing the current device.\n Works on all platforms including web.", + "annotations": [] + }, + { + "name": "_getWebDeviceType", + "returnType": "DeviceType", + "signature": [], + "features": [ + "static" + ], + "description": " Detects device type for web platforms", + "annotations": [] + }, + { + "name": "_getNativeDeviceType", + "returnType": "DeviceType", + "signature": [], + "features": [ + "static" + ], + "description": " Detects device type for native platforms (iOS, Android, macOS, Windows, Linux)", + "annotations": [] + }, + { + "name": "getDeviceTypeString", + "returnType": "String", + "signature": [], + "features": [ + "static" + ], + "description": " Gets a human-readable string representation of the device type", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/device_info.dart", + "name": "DeviceType", + "isNullSafe": true, + "description": " Enum representing different device types", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "phone", + "type": "DeviceType", + "description": " Mobile phone devices", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "tablet", + "type": "DeviceType", + "description": " Tablet devices", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "desktop", + "type": "DeviceType", + "description": " Desktop/laptop computers", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "web", + "type": "DeviceType", + "description": " Web browsers", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "unknown", + "type": "DeviceType", + "description": " Unknown device type", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/annotations.dart", + "name": "Variants", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "variants", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "variants", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/annotations.dart", + "name": "Variant", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "defaults", + "description": "", + "type": "Map", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "name", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "defaults", + "type": "Map", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/annotations.dart", + "name": "ContextConfigurable", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/choose/choose.dart", + "name": "LdChooseTriggerConfig", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "selectedItems", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectedIds", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "state", + "description": "", + "type": "LdSubmitState>", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onTap", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "truncateDisplay", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hint", + "description": "", + "type": "Widget?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectedItemBuilder", + "description": "", + "type": "Widget Function(BuildContext, T)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "selectedItems", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectedIds", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "state", + "type": "LdSubmitState>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onTap", + "type": "void Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "truncateDisplay", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "label", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hint", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectedItemBuilder", + "type": "Widget Function(BuildContext, T)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/choose/choose.dart", + "name": "LdChoose", + "isNullSafe": true, + "description": " A widget that presents a dropdown in a seperate page.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "repository", + "description": "", + "type": "LdRepository?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "items", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "itemBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorItem, int)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectedItemBuilder", + "description": "", + "type": "Widget Function(BuildContext, T)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowEmpty", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "useRootNavigator", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "multiple", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdChooseMode", + "named": true, + "required": false, + "defaultValue": "LdChooseMode.auto", + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(Set)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hint", + "description": "", + "type": "Text?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "truncateDisplay", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "Set?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "triggerBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdChooseTriggerConfig)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "repository", + "type": "LdRepository?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "items", + "type": "List?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "itemBuilder", + "type": "Widget Function(BuildContext, LdPaginatorItem, int)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectedItemBuilder", + "type": "Widget Function(BuildContext, T)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowEmpty", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mode", + "type": "LdChooseMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "useRootNavigator", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "multiple", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "value", + "type": "Set?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(Set)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "truncateDisplay", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hint", + "type": "Text?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "triggerBuilder", + "type": "Widget Function(BuildContext, LdChooseTriggerConfig)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "fromList", + "returnType": "dynamic", + "signature": [ + { + "name": "items", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(Set)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "itemBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorItem, int)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectedItemBuilder", + "description": "", + "type": "Widget Function(BuildContext, T)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "triggerBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdChooseTriggerConfig)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "Set?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowEmpty", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "useRootNavigator", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "multiple", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdChooseMode", + "named": true, + "required": false, + "defaultValue": "LdChooseMode.auto", + "annotations": [] + }, + { + "name": "placeholder", + "description": "", + "type": "Text?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "truncateDisplay", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Convenience constructor that creates an LdChoose from a list of LdSelectItem.\n\n This constructor automatically creates a repository from the items and\n uses the child widget from each LdSelectItem for rendering.", + "annotations": [] + }, + { + "name": "fromSelectItems", + "returnType": "LdChoose, T>", + "signature": [ + { + "name": "items", + "description": "", + "type": "List>", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "void Function(Set)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "Set?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowEmpty", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "useRootNavigator", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "multiple", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdChooseMode", + "named": true, + "required": false, + "defaultValue": "LdChooseMode.auto", + "annotations": [] + }, + { + "name": "placeholder", + "description": "", + "type": "Text?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "truncateDisplay", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "triggerBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdChooseTriggerConfig, T>)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/choose/choose.dart", + "name": "_LdChooseState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_repository", + "type": "LdRepository", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_ownsRepository", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdChoose", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_fetchSelectedItems", + "returnType": "Future>", + "signature": [ + { + "name": "ids", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onTap", + "returnType": "Future", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getDisplayItems", + "returnType": "int", + "signature": [ + { + "name": "ids", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/choose/choose.dart", + "name": "LdChoosePage", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "repository", + "description": "", + "type": "LdRepository", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "itemBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorItem, int)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialSelectedItems", + "description": "", + "type": "Set", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "multiple", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowEmpty", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "repository", + "type": "LdRepository", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "itemBuilder", + "type": "Widget Function(BuildContext, LdPaginatorItem, int)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialSelectedItems", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "multiple", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowEmpty", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "label", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/choose/choose.dart", + "name": "_LdChoosePageState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_selectedItems", + "type": "Set", + "description": "", + "features": [ + "late" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdChoosePage", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_handleSelectionChange", + "returnType": "void", + "signature": [ + { + "name": "selectedItems", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/choose/choose.dart", + "name": "LdChooseMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "page", + "type": "LdChooseMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "modal", + "type": "LdChooseMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "auto", + "type": "LdChooseMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/choose/choose.dart", + "name": "LdChooseTriggerBuilder", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "Widget Function(BuildContext, LdChooseTriggerConfig)", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/choose/choose_list_item_trigger.dart", + "name": "LdChooseListItemTrigger", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdChooseTriggerConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "separator", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "config", + "type": "LdChooseTriggerConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "separator", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/choose/choose_input_trigger.dart", + "name": "LdChooseInputTrigger", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdChooseTriggerConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "separator", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "config", + "type": "LdChooseTriggerConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "separator", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/text_list.dart", + "name": "LdTextList", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "items", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextListType", + "named": true, + "required": false, + "defaultValue": "LdTextListType.bulleted", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "items", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdTextListType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "Color?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "lineHeight", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "fontWeight", + "type": "FontWeight?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "textAlign", + "type": "TextAlign?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxLines", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "overflow", + "type": "TextOverflow?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_getBulletOrNumber", + "returnType": "String", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/text_list.dart", + "name": "LdTextListType", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "bulleted", + "type": "LdTextListType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "enumerated", + "type": "LdTextListType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/autospace.dart", + "name": "_Default", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Describes the part of the user interface represented by this widget.\n\n The framework calls this method when this widget is inserted into the tree\n in a given [BuildContext] and when the dependencies of this widget change\n (e.g., an [InheritedWidget] referenced by this widget changes). This\n method can potentially be called in every frame and should not have any side\n effects beyond building a widget.\n\n The framework replaces the subtree below this widget with the widget\n returned by this method, either by updating the existing subtree or by\n removing the subtree and inflating a new subtree, depending on whether the\n widget returned by this method can update the root of the existing\n subtree, as determined by calling [Widget.canUpdate].\n\n Typically implementations return a newly created constellation of widgets\n that are configured with information from this widget's constructor and\n from the given [BuildContext].\n\n The given [BuildContext] contains information about the location in the\n tree at which this widget is being built. For example, the context\n provides the set of inherited widgets for this location in the tree. A\n given widget might be built with multiple different [BuildContext]\n arguments over time if the widget is moved around the tree or if the\n widget is inserted into the tree in multiple places at once.\n\n The implementation of this method must only depend on:\n\n * the fields of the widget, which themselves must not change over time,\n and\n * any ambient state obtained from the `context` using\n [BuildContext.dependOnInheritedWidgetOfExactType].\n\n If a widget's [build] method is to depend on anything else, use a\n [StatefulWidget] instead.\n\n See also:\n\n * [StatelessWidget], which contains the discussion on performance considerations.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/autospace.dart", + "name": "_LdSizeItem", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "multiplier", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "multiplier", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/autospace.dart", + "name": "LdAutoSpace", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "children", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "defaultSpacing", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.start", + "annotations": [] + }, + { + "name": "animate", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "children", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "defaultSpacing", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "type": "CrossAxisAlignment", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "animate", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_generateSpacings", + "returnType": "List", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/autospace.dart", + "name": "LdBundle", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "children", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "children", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/autospace.dart", + "name": "LdAutoSpaceExt", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "autoSpace", + "returnType": "List", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "defaultSpacing", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "animate", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "List", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/autospace.dart", + "name": "generateAutoSpacings", + "isNullSafe": true, + "description": " Generates auto-spaced widgets from a list of children based on spacing rules.\n\n This function applies automatic spacing between widgets based on their types,\n following the spacing matrix rules and special handling for text widgets.\n\n Parameters:\n - [children]: The list of widgets to be spaced\n - [context]: The build context for theme access\n - [defaultSpacing]: The default spacing to use when no specific rule applies\n - [animate]: Whether to apply animation to the widgets\n\n Returns a list of widgets with appropriate spacing inserted between them.", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "generateAutoSpacings", + "returnType": "List", + "signature": [ + { + "name": "children", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "defaultSpacing", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "animate", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Generates auto-spaced widgets from a list of children based on spacing rules.\n\n This function applies automatic spacing between widgets based on their types,\n following the spacing matrix rules and special handling for text widgets.\n\n Parameters:\n - [children]: The list of widgets to be spaced\n - [context]: The build context for theme access\n - [defaultSpacing]: The default spacing to use when no specific rule applies\n - [animate]: Whether to apply animation to the widgets\n\n Returns a list of widgets with appropriate spacing inserted between them.", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/select.dart", + "name": "LdSelectItem", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "value", + "description": "", + "type": "T", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "enabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "searchString", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "id", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "idString", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "value", + "type": "T", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "enabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "searchString", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [ + "Identifiable" + ] + }, + { + "filePath": "lib/src/select.dart", + "name": "LdSelect", + "isNullSafe": true, + "description": " a wrapper around [DropdownButton]", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "items", + "description": "", + "type": "List>", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "placeholder", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "valid", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "onSurface", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "items", + "type": "List>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "placeholder", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSurface", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "value", + "type": "T?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "valid", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(T)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/select.dart", + "name": "_LdSelectState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_focusNodeChildren", + "type": "FocusScopeNode?", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_controller", + "type": "ScrollController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdSelect", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_buildInitialItem", + "returnType": "Widget", + "signature": [ + { + "name": "activeItem", + "description": "", + "type": "LdSelectItem?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "placeholderColor", + "description": "", + "type": "Color", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Builds the initial item (selected or placeholder)", + "annotations": [] + }, + { + "name": "_buildDropdownItem", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "item", + "description": "", + "type": "LdSelectItem", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isActive", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "defaultTextStyle", + "description": "", + "type": "TextStyle", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Builds a single dropdown item", + "annotations": [] + }, + { + "name": "_buildDropdownMenu", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "activeItem", + "description": "", + "type": "LdSelectItem?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "defaultTextStyle", + "description": "", + "type": "TextStyle", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Builds the dropdown menu content", + "annotations": [] + }, + { + "name": "_buildDropdownButton", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "activeItem", + "description": "", + "type": "LdSelectItem?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "defaultTextStyle", + "description": "", + "type": "TextStyle", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "open", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOpen", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Builds the dropdown button (the visible part before opening the menu)", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/select.dart", + "name": "ScrollIntoView", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scroll", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "scroll", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/text.dart", + "name": "_LdTextWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "processLinks", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "Color?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "lineHeight", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "fontWeight", + "type": "FontWeight?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxLines", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdTextType?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "text", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "textAlign", + "type": "TextAlign?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "decoration", + "type": "TextDecoration?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "overflow", + "type": "TextOverflow?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onLinkTap", + "type": "void Function(String)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('caption', defaults: {'type' : 'LdTextType.caption'}), Variant('h', defaults: {'type' : 'LdTextType.headline', 'size' : 'LdSize.m'}), Variant('hl', defaults: {'type' : 'LdTextType.headline', 'size' : 'LdSize.l'}), Variant('hs', defaults: {'type' : 'LdTextType.headline', 'size' : 'LdSize.s'}), Variant('hxs', defaults: {'type' : 'LdTextType.headline', 'size' : 'LdSize.xs'}), Variant('l', defaults: {'type' : 'LdTextType.label'}), Variant('ll', defaults: {'type' : 'LdTextType.label', 'size' : 'LdSize.l'}), Variant('ls', defaults: {'type' : 'LdTextType.label', 'size' : 'LdSize.s'}), Variant('lxs', defaults: {'type' : 'LdTextType.label', 'size' : 'LdSize.xs'}), Variant('p', defaults: {'type' : 'LdTextType.paragraph'}), Variant('pl', defaults: {'type' : 'LdTextType.paragraph', 'size' : 'LdSize.l'}), Variant('ps', defaults: {'type' : 'LdTextType.paragraph', 'size' : 'LdSize.s'}), Variant('pxs', defaults: {'type' : 'LdTextType.paragraph', 'size' : 'LdSize.xs'})])" + ], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/text.dart", + "name": "LdText", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "p", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "pl", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "ps", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "pxs", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "hl", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "h", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "hs", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "hxs", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "l", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "ls", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "ll", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "lxs", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "caption", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textAlign", + "description": "", + "type": "TextAlign?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "overflow", + "description": "", + "type": "TextOverflow?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "TextDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": true, + "required": false, + "defaultValue": "LdTextType.paragraph", + "annotations": [] + }, + { + "name": "onLinkTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "processLinks", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "text", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "textAlign", + "type": "TextAlign?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxLines", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "lineHeight", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "overflow", + "type": "TextOverflow?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "decoration", + "type": "TextDecoration?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "fontWeight", + "type": "FontWeight?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "Color?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "processLinks", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdTextType?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onLinkTap", + "type": "void Function(String)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/text.dart", + "name": "LdTextType", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "headline", + "type": "LdTextType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "paragraph", + "type": "LdTextType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "label", + "type": "LdTextType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "caption", + "type": "LdTextType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/text.dart", + "name": "ldBuildTextStyle", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ldBuildTextStyle", + "returnType": "TextStyle", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdTextType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lineHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fontWeight", + "description": "", + "type": "FontWeight?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/text.dart", + "name": "_buildTextSpanWithLinks", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "_buildTextSpanWithLinks", + "returnType": "TextSpan", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "TextStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onTap", + "description": "", + "type": "void Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/text.dart", + "name": "ldLineHeight", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ldLineHeight", + "returnType": "double", + "signature": [ + { + "name": "type", + "description": "", + "type": "LdTextType?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit_loading_indicator.dart", + "name": "LdSubmitLoadingIndicator", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "direction", + "description": "", + "type": "Axis", + "named": true, + "required": false, + "defaultValue": "Axis.horizontal", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "loading", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingText", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "direction", + "type": "Axis", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/notification_builder.dart", + "name": "LdSubmitNotificationBuilder", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "resultBuilder", + "description": "", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "showSubmitButton", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "successMessage", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "resultBuilder", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorBuilder", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showSubmitButton", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "successMessage", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "buildSubmitButton", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdSubmitController", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdSubmitBuilder", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/notification_builder.dart", + "name": "_LdSubmitNotification", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "resultBuilder", + "description": "", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "showSubmitButton", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "successMessage", + "description": "", + "type": "String?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "resultBuilder", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "successMessage", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "showSubmitButton", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_LdSubmitNotification>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/notification_builder.dart", + "name": "_LdSubmitNotificationState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_submitController", + "type": "LdSubmitController", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_subscription", + "type": "StreamSubscription?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_notificationsController", + "type": "LdNotificationsController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_notification", + "type": "LdNotification?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_LdSubmitNotification", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_dismissNotification", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onStateChanged", + "returnType": "void", + "signature": [ + { + "name": "state", + "description": "", + "type": "LdSubmitState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdSubmitController", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/dialog_builder.dart", + "name": "LdSubmitDialogBuilder", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "resultBuilder", + "description": "", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loadingBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "showSubmitButton", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "targetRoot", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "resultBuilder", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorBuilder", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showSubmitButton", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "targetRoot", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdSubmitBuilder", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/dialog_builder.dart", + "name": "_LdSubmitDialog", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "resultBuilder", + "description": "", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loadingBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "showSubmitButton", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "targetRoot", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "resultBuilder", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorBuilder", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "showSubmitButton", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "targetRoot", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_LdSubmitDialog>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/dialog_builder.dart", + "name": "_LdSubmitDialogState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_overlayController", + "type": "OverlayPortalController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_submitController", + "type": "LdSubmitController", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_subscription", + "type": "StreamSubscription?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_LdSubmitDialog", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_onStateChanged", + "returnType": "void", + "signature": [ + { + "name": "state", + "description": "", + "type": "LdSubmitState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "buildLoadingDialog", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdSubmitController", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "buildErrorDialog", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdSubmitController", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_overlayChildBuilder", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/custom_builder.dart", + "name": "LdSubmitCustomBuilder", + "isNullSafe": true, + "description": " A custom builder that allows you to build your own submit widget.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController, LdSubmitStateType)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, LdSubmitController, LdSubmitStateType)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/centered_builder.dart", + "name": "LdSubmitCenteredBuilder", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "resultBuilder", + "description": "", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loadingBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "resultBuilder", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorBuilder", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdSubmitBuilder", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/inline_builder.dart", + "name": "LdSubmitInlineBuilder", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "resultBuilder", + "description": "", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "showSubmitButton", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "resultBuilder", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorBuilder", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showSubmitButton", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "buildSubmitButton", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdSubmitController", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdSubmitBuilder", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/builders/submit_button.dart", + "name": "LdSubmitButton", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdSubmitController", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "controller", + "type": "LdSubmitController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/model/submit_controller.dart", + "name": "LdSubmitController", + "isNullSafe": true, + "description": " Handles the lifecyle of a submit action. Pass a [LdSubmitConfig] to the\n controller to configure the submit action.\n Updated LdSubmitController that uses LdRetryController", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdSubmitConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "arg", + "description": "", + "type": "ValueNotifier?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "config", + "type": "LdSubmitConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "id", + "type": "String", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_stateController", + "type": "StreamController>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_retryController", + "type": "LdRetryController", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "arg", + "type": "ValueNotifier?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "state", + "type": "LdSubmitState", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_disposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "retryController", + "type": "LdRetryController", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "stateStream", + "type": "Stream>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "canCancel", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isError", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isLoading", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isResult", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isIdle", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "canRetry", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "canRetrigger", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "canTrigger", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "disposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_onArgChanged", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "init", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_setState", + "returnType": "void", + "signature": [ + { + "name": "newState", + "description": "", + "type": "LdSubmitState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "cancel", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_trigger", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "debugForceError", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "trigger", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_nextAttempt", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "reset", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toMap", + "returnType": "Map", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/model/submit_config.dart", + "name": "LdSubmitConfig", + "isNullSafe": true, + "description": " A configuration for a submit action.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "submitText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowResubmit", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "withHaptics", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoTrigger", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "allowCancel", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "onCanceled", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "timeout", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "retryConfig", + "description": "", + "type": "LdRetryConfig?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "action", + "description": "", + "type": "Future Function(Arg?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugLabel", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "props", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "stringify", + "type": "bool?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingText", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitText", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowResubmit", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "withHaptics", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoTrigger", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "timeout", + "type": "Duration?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowCancel", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "action", + "type": "Future Function(Arg?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onCanceled", + "type": "void Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "retryConfig", + "type": "LdRetryConfig?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugLabel", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hapticsEnabled", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Equatable", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/model/devtools.dart", + "name": "SubmitDevTools", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "_", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_instance", + "type": "SubmitDevTools", + "description": "", + "features": [ + "static", + "final" + ], + "annotations": [] + }, + { + "name": "_subscriptions", + "type": "List>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_initialized", + "type": "bool", + "description": "", + "features": [ + "static" + ], + "annotations": [] + }, + { + "name": "_controllers", + "type": "List>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "instance", + "type": "SubmitDevTools", + "description": "", + "features": [ + "static" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_registerDevToolsExtension", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "registerController", + "returnType": "void", + "signature": [ + { + "name": "controller", + "description": "", + "type": "LdSubmitController", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "unregisterController", + "returnType": "void", + "signature": [ + { + "name": "controller", + "description": "", + "type": "LdSubmitController", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/model/submit_controller_dto.dart", + "name": "SubmitControllerDto", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "id", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "state", + "description": "", + "type": "SubmitControllerStateDto", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canRetry", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canRetrigger", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowCancel", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowResubmit", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canTrigger", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoTrigger", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "withHaptics", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugLabel", + "description": "", + "type": "String?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "id", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "state", + "type": "SubmitControllerStateDto", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "canRetry", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "canRetrigger", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "canTrigger", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoTrigger", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowCancel", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowResubmit", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugLabel", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "withHaptics", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "toMap", + "returnType": "Map", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fromMap", + "returnType": "SubmitControllerDto", + "signature": [ + { + "name": "map", + "description": "", + "type": "Map", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "fromLdSubmitController", + "returnType": "SubmitControllerDto", + "signature": [ + { + "name": "controller", + "description": "", + "type": "LdSubmitController", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/model/submit_controller_dto.dart", + "name": "SubmitControllerStateDto", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "type", + "description": "", + "type": "LdSubmitStateType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "error", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "result", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "type", + "type": "LdSubmitStateType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "error", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "result", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "toMap", + "returnType": "Map", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fromMap", + "returnType": "SubmitControllerStateDto", + "signature": [ + { + "name": "map", + "description": "", + "type": "Map", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "fromLdSubmitState", + "returnType": "SubmitControllerStateDto", + "signature": [ + { + "name": "state", + "description": "", + "type": "LdSubmitState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/model/submit_controller_dto.dart", + "name": "RetryControllerDto", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "attempt", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "remainingRetryTime", + "description": "", + "type": "Duration?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isRetrying", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canRetry", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "totalRetryDelay", + "description": "", + "type": "Duration?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "attempt", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "remainingRetryTime", + "type": "Duration?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isRetrying", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "canRetry", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "totalRetryDelay", + "type": "Duration?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "toMap", + "returnType": "Map", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fromMap", + "returnType": "RetryControllerDto", + "signature": [ + { + "name": "map", + "description": "", + "type": "Map", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/model/submit_controller_dto.dart", + "name": "SubmitConfigDto", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "autoTrigger", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowCancel", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowResubmit", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hapticsEnabled", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "timeout", + "description": "", + "type": "String?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "action", + "description": "", + "type": "Future Function(dynamic)?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "autoTrigger", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowCancel", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowResubmit", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hapticsEnabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "timeout", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "action", + "type": "Future Function(dynamic)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "toMap", + "returnType": "Map", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fromMap", + "returnType": "SubmitConfigDto", + "signature": [ + { + "name": "map", + "description": "", + "type": "Map", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "fromLdSubmitConfig", + "returnType": "SubmitConfigDto", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdSubmitConfig", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/model/submit_state.dart", + "name": "LdSubmitState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "type", + "description": "", + "type": "LdSubmitStateType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "error", + "description": "", + "type": "LdException?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "result", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_type", + "type": "LdSubmitStateType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_error", + "type": "LdException?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_result", + "type": "T?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdSubmitStateType", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "error", + "type": "LdException?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "result", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "copyWith", + "returnType": "LdSubmitState", + "signature": [ + { + "name": "type", + "description": "", + "type": "LdSubmitStateType?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "error", + "description": "", + "type": "LdException?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "result", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit.dart", + "name": "LdSubmitBuilder", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "resultBuilder", + "description": "", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loadingBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "resultBuilder", + "type": "Widget Function(BuildContext, T, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitButtonBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingBuilder", + "type": "Widget Function(BuildContext, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorBuilder", + "type": "Widget Function(BuildContext, LdException, LdSubmitController)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Describes the part of the user interface represented by this widget.\n\n The framework calls this method when this widget is inserted into the tree\n in a given [BuildContext] and when the dependencies of this widget change\n (e.g., an [InheritedWidget] referenced by this widget changes). This\n method can potentially be called in every frame and should not have any side\n effects beyond building a widget.\n\n The framework replaces the subtree below this widget with the widget\n returned by this method, either by updating the existing subtree or by\n removing the subtree and inflating a new subtree, depending on whether the\n widget returned by this method can update the root of the existing\n subtree, as determined by calling [Widget.canUpdate].\n\n Typically implementations return a newly created constellation of widgets\n that are configured with information from this widget's constructor and\n from the given [BuildContext].\n\n The given [BuildContext] contains information about the location in the\n tree at which this widget is being built. For example, the context\n provides the set of inherited widgets for this location in the tree. A\n given widget might be built with multiple different [BuildContext]\n arguments over time if the widget is moved around the tree or if the\n widget is inserted into the tree in multiple places at once.\n\n The implementation of this method must only depend on:\n\n * the fields of the widget, which themselves must not change over time,\n and\n * any ambient state obtained from the `context` using\n [BuildContext.dependOnInheritedWidgetOfExactType].\n\n If a widget's [build] method is to depend on anything else, use a\n [StatefulWidget] instead.\n\n See also:\n\n * [StatelessWidget], which contains the discussion on performance considerations.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit.dart", + "name": "LdSubmit", + "isNullSafe": true, + "description": " A component that handles making requests and displaying errors.\n You can use this component to wrap around a button that makes a request.\n It will handle the loading state and display errors.\n It also has a default exception mapper that will handle common exceptions.\n You can also provide your own exception mapper.\n The default builder is a button that will display a loading spinner when loading.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "arg", + "description": "", + "type": "Arg?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "config", + "description": "", + "type": "LdSubmitConfig?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdSubmitController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "argEquals", + "description": "", + "type": "bool Function(Arg?, Arg?)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "config", + "type": "LdSubmitConfig?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "controller", + "type": "LdSubmitController?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "arg", + "type": "Arg?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "argEquals", + "type": "bool Function(Arg?, Arg?)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit.dart", + "name": "_LdSubmitState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_argNotifier", + "type": "ValueNotifier", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_controller", + "type": "LdSubmitController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_createdController", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "submitBuilder", + "type": "Widget", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdSubmit", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_buildProvider", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit.dart", + "name": "LdSubmitStateType", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "idle", + "type": "LdSubmitStateType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "loading", + "type": "LdSubmitStateType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "error", + "type": "LdSubmitStateType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "result", + "type": "LdSubmitStateType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit.dart", + "name": "LdSubmitCallback", + "isNullSafe": true, + "description": " A callback that triggers the action", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "Future Function(Arg?)", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit.dart", + "name": "LdSubmitResultBuilder", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "Widget Function(BuildContext, T, LdSubmitController)", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit.dart", + "name": "LdSubmitButtonBuilder", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "Widget Function(BuildContext, LdSubmitController)", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit.dart", + "name": "LdSubmitLoadingBuilder", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "Widget Function(BuildContext, LdSubmitController)", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/submit/submit.dart", + "name": "LdSubmitErrorBuilder", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "Widget Function(BuildContext, LdException, LdSubmitController)", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/form.dart", + "name": "LdFormHint", + "isNullSafe": true, + "description": " Hint for a form field", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "hint", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "hint", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "type", + "type": "LdHintType", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/form.dart", + "name": "LdFormItem", + "isNullSafe": true, + "description": " A form item in a [LdForm]", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/form.dart", + "name": "LdForm", + "isNullSafe": true, + "description": " Liquid Design Form that wraps a [Form] widget", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "fields", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "hints", + "description": "", + "type": "Map", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "onSubmit", + "description": "", + "type": "Future Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "submitButtonMode", + "description": "", + "type": "LdButtonMode", + "named": true, + "required": false, + "defaultValue": "LdButtonMode.filled", + "annotations": [] + }, + { + "name": "submitString", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fields", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loading", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitString", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "submitButtonMode", + "type": "LdButtonMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hints", + "type": "Map", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSubmit", + "type": "Future Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/form.dart", + "name": "_LdFormState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_loading", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdForm", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_buildHint", + "returnType": "Widget", + "signature": [ + { + "name": "key", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildField", + "returnType": "Widget", + "signature": [ + { + "name": "field", + "description": "", + "type": "LdFormItem", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildSubmit", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/toggle.dart", + "name": "LdToggle", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "checked", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/toggle.dart", + "name": "_LdToggleState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_ticker", + "type": "Ticker?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickerModeNotifier", + "type": "ValueListenable?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_controller", + "type": "AnimationController", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_theme", + "type": "LdTheme", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_thumbSize", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_gap", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdToggle", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "createTicker", + "returnType": "Ticker", + "signature": [ + { + "name": "onTick", + "description": "", + "type": "void Function(Duration)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Creates a ticker with the given callback.\n\n The kind of ticker provided depends on the kind of ticker provider.", + "annotations": [ + "@factory" + ] + }, + { + "name": "_updateTicker", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickerModeNotifier", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateStatus", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onTap", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "SingleTickerProviderStateMixin" + ] + }, + { + "filePath": "lib/src/haptics.dart", + "name": "LdHaptics", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [], + "methods": [ + { + "name": "vibrate", + "returnType": "Future", + "signature": [ + { + "name": "type", + "description": "", + "type": "HapticsType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/badge.dart", + "name": "LdBadgeWidget", + "isNullSafe": true, + "description": " A rounded fully opaque label with a background [color].\n Can be used to display a small amount of information.\n", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "symmetric", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "symmetric", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxLines", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('success', defaults: {'color' : 'LdTheme.of(context).success'}), Variant('warning', defaults: {'color' : 'LdTheme.of(context).warning'}), Variant('error', defaults: {'color' : 'LdTheme.of(context).error'})])" + ], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/badge.dart", + "name": "LdBadge", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "symmetric", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "symmetric", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxLines", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "success", + "returnType": "Widget", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "symmetric", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "warning", + "returnType": "Widget", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "symmetric", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "error", + "returnType": "Widget", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "symmetric", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/portal.dart", + "name": "ProviderOrValue", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "create", + "description": "", + "type": "T Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "dispose", + "description": "", + "type": "void Function(BuildContext, T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, Widget?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "value", + "type": "T?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "create", + "type": "T Function(BuildContext)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "dispose", + "type": "void Function(BuildContext, T)?", + "description": " Dispose function for the provider, only used if [value] is null", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, Widget?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/runner.dart", + "name": "LdRunnerLog", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "messages", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "messages", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/runner.dart", + "name": "_LdRunnerLogState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_node", + "type": "FocusNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdRunnerLog", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "buildLine", + "returnType": "Widget", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/runner.dart", + "name": "LdRunnerStep", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isExpanded", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "onPress", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "children", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "title", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "status", + "type": "LdIndicatorType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isExpanded", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPress", + "type": "void Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "children", + "type": "List?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/card.dart", + "name": "LdCard", + "isNullSafe": true, + "description": " A simple card component with a shadow to elevate it from the page. Header and Footer are optional and separated by color.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "header", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "footer", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "flat", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "expandChild", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "header", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "footer", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "expandChild", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "flat", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/button.dart", + "name": "_LdButtonWidget", + "isNullSafe": true, + "description": " A pressable button", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoLoading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode", + "named": true, + "required": false, + "defaultValue": "LdButtonMode.filled", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "progress", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "FutureOr Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loading", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoLoading", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "progress", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoFocus", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disableSqueeze", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mode", + "type": "LdButtonMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "alignment", + "type": "MainAxisAlignment?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "circular", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingText", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorText", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_LdButtonWidget>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('ghost', defaults: {'mode' : 'LdButtonMode.ghost'}), Variant('vague', defaults: {'mode' : 'LdButtonMode.vague'}), Variant('outline', defaults: {'mode' : 'LdButtonMode.outline'}), Variant('filled', defaults: {'mode' : 'LdButtonMode.filled'}), Variant('warning', defaults: {'color' : 'LdTheme.of(context).warning'}), Variant('error', defaults: {'color' : 'LdTheme.of(context).error'}), Variant('success', defaults: {'color' : 'LdTheme.of(context).success'})])" + ], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/button.dart", + "name": "_LdButtonState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_loading", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_failed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_error", + "type": "LdException?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_theme", + "type": "LdTheme", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_child", + "type": "Widget", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_trailing", + "type": "Widget", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_alignment", + "type": "MainAxisAlignment", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "centerText", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_buttonContent", + "type": "Widget", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_leading", + "type": "Widget", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_circular", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_LdButtonWidget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_loadingContent", + "returnType": "Widget", + "signature": [ + { + "name": "bundle", + "description": "", + "type": "LdColorBundle", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onTap", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/button.dart", + "name": "_ButtonShape", + "isNullSafe": true, + "description": " Build the button shape", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "mode", + "description": "", + "type": "LdButtonMode", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "colors", + "description": "", + "type": "LdColorBundle", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "center", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "panOffset", + "description": "", + "type": "Offset?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mode", + "type": "LdButtonMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "colors", + "type": "LdColorBundle", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "center", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disableSqueeze", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "circular", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "status", + "type": "LdTouchableStatus", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "panOffset", + "type": "Offset?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_border", + "returnType": "Border?", + "signature": [ + { + "name": "context", + "description": "", + "type": "dynamic", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_padding", + "returnType": "EdgeInsets", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/button.dart", + "name": "LdButtonConfig", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "autoLoading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "autoLoading", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "alignment", + "type": "MainAxisAlignment?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "circular", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mode", + "type": "LdButtonMode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disableSqueeze", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/button.dart", + "name": "LdButtonConfigProvider", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdButtonConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "config", + "type": "LdButtonConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/button.dart", + "name": "LdButton", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoLoading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "progress", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "ghost", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoLoading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "progress", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "vague", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoLoading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "progress", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "outline", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoLoading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "progress", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "filled", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoLoading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "progress", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "FutureOr Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loading", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoLoading", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "progress", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoFocus", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disableSqueeze", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mode", + "type": "LdButtonMode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "alignment", + "type": "MainAxisAlignment?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "circular", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingText", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorText", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "warning", + "returnType": "Widget", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoLoading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "progress", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "error", + "returnType": "Widget", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoLoading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "progress", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "success", + "returnType": "Widget", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "FutureOr Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoLoading", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "MainAxisAlignment?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "loadingText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdButtonMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "progress", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableSqueeze", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/button.dart", + "name": "LdButtonMode", + "isNullSafe": true, + "description": " Determines the mode of the button", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "filled", + "type": "LdButtonMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "outline", + "type": "LdButtonMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "ghost", + "type": "LdButtonMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "vague", + "type": "LdButtonMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold_body.dart", + "name": "LdScaffoldBody", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "children", + "description": "", + "type": "List", + "named": true, + "required": false, + "defaultValue": "const []", + "annotations": [] + }, + { + "name": "minimumPadding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "slivers", + "description": "", + "type": "List", + "named": true, + "required": false, + "defaultValue": "const []", + "annotations": [] + }, + { + "name": "scrollController", + "description": "", + "type": "ScrollController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "backgroundColor", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autoSpaceChildren", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "addContainer", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "children", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "slivers", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "minimumPadding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "backgroundColor", + "type": "Color?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scrollController", + "type": "ScrollController?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoSpaceChildren", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "addContainer", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/blurring_header.dart", + "name": "LdBlurringHeader", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scrollController", + "description": "", + "type": "ScrollController", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scrollController", + "type": "ScrollController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/blurring_header.dart", + "name": "_LdBlurringHeaderState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "scrollOffset", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdBlurringHeader", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_updateScrollOffset", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/container.dart", + "name": "LdContainer", + "isNullSafe": true, + "description": " Allows you to horizontally center your content on a larger screen by padding it on the sides", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxWidth", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxWidth", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/color/palette.dart", + "name": "LdPalette", + "isNullSafe": true, + "description": " Describes how to build a pallete of colors for a theme.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "isDark", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "primary", + "description": "", + "type": "LdColor", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondary", + "description": "", + "type": "LdColor", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "success", + "description": "", + "type": "LdColor", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "warning", + "description": "", + "type": "LdColor", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "error", + "description": "", + "type": "LdColor", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "neutral", + "description": "", + "type": "LdColor", + "named": true, + "required": false, + "defaultValue": "shadZinc", + "annotations": [] + }, + { + "name": "background", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "surface", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "border", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stroke", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "text", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textMuted", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "floatingBorder", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "isDark", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "primary", + "type": "LdColor", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "secondary", + "type": "LdColor", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "success", + "type": "LdColor", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "warning", + "type": "LdColor", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "error", + "type": "LdColor", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "neutral", + "type": "LdColor", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "background", + "type": "Color", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "surface", + "type": "Color", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "border", + "type": "Color", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "floatingBorder", + "type": "Color", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "stroke", + "type": "Color", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "text", + "type": "Color", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "textMuted", + "type": "Color", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/color/color.dart", + "name": "LdColor", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "shades", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "_center", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "_darkCenter", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "luminanceThreshold", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0.179", + "annotations": [] + }, + { + "name": "disabledAlpha", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "150", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "shades", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_center", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_darkCenter", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "luminanceThreshold", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabledAlpha", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "center", + "returnType": "Color", + "signature": [ + { + "name": "isDark", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fromCenter", + "returnType": "Color", + "signature": [ + { + "name": "offset", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isDark", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fromDarkCenter", + "returnType": "Color", + "signature": [ + { + "name": "offset", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Get the dark center color of the palette", + "annotations": [] + }, + { + "name": "moveRelative", + "returnType": "Color", + "signature": [ + { + "name": "color", + "description": "", + "type": "Color", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Move the color relative to the palette\n returns the new color", + "annotations": [] + }, + { + "name": "relative", + "returnType": "Color", + "signature": [ + { + "name": "isDark", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "idle", + "returnType": "Color", + "signature": [ + { + "name": "dark", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "hover", + "returnType": "Color", + "signature": [ + { + "name": "dark", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "active", + "returnType": "Color", + "signature": [ + { + "name": "dark", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "focus", + "returnType": "Color", + "signature": [ + { + "name": "dark", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "locateColor", + "returnType": "String", + "signature": [ + { + "name": "color", + "description": "", + "type": "Color", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Locate the color in the palette\n Prints the palette with the color highlighted, and the center and\n dark center marked", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_calcContrast", + "returnType": "double", + "signature": [ + { + "name": "a", + "description": "", + "type": "Color", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "b", + "description": "", + "type": "Color", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "contrastingText", + "returnType": "Color", + "signature": [ + { + "name": "color", + "description": "", + "type": "Color", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "background", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isDark", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Get the contrasting text color for the given color", + "annotations": [] + }, + { + "name": "disabled", + "returnType": "LdColor", + "signature": [ + { + "name": "isDark", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/checkbox.dart", + "name": "_LdCheckboxWidget", + "isNullSafe": true, + "description": " A checkbox control.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.s", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "checked", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_LdCheckboxWidget>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('success', defaults: {'color' : 'LdTheme.of(context).success'}), Variant('warning', defaults: {'color' : 'LdTheme.of(context).warning'}), Variant('error', defaults: {'color' : 'LdTheme.of(context).error'})])" + ], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/checkbox.dart", + "name": "_LdCheckboxState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_LdCheckboxWidget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/checkbox.dart", + "name": "LdCheckboxConfig", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "checked", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "checked", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/checkbox.dart", + "name": "LdCheckboxConfigProvider", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdCheckboxConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "config", + "type": "LdCheckboxConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/checkbox.dart", + "name": "LdCheckbox", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "checked", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "success", + "returnType": "Widget", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "warning", + "returnType": "Widget", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "error", + "returnType": "Widget", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/checkbox.dart", + "name": "ldCheckboxPreview", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ldCheckboxPreview", + "returnType": "Widget", + "signature": [], + "features": [ + "static" + ], + "description": "", + "annotations": [ + "@LiquidMultiPreview(name: 'LdCheckbox checked')" + ] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [ + "@LiquidMultiPreview(name: 'LdCheckbox checked')" + ], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/checkbox.dart", + "name": "ldCheckboxPreviewUnchecked", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ldCheckboxPreviewUnchecked", + "returnType": "Widget", + "signature": [], + "features": [ + "static" + ], + "description": "", + "annotations": [ + "@LiquidMultiPreview(name: 'LdCheckbox unchecked')" + ] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [ + "@LiquidMultiPreview(name: 'LdCheckbox unchecked')" + ], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/multi_panel/multi_panel_layout.dart", + "name": "LdMultiPanelLayout", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "children", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "widths", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdMultiPanelLayoutMode", + "named": true, + "required": false, + "defaultValue": "LdMultiPanelLayoutMode.sideBySide", + "annotations": [] + }, + { + "name": "visibleStartIndex", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "enableBorders", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "visibleEndIndex", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + }, + { + "name": "onVisibleRangeChanged", + "description": "", + "type": "void Function(int, int)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mass", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "5", + "annotations": [] + }, + { + "name": "springConstant", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "3", + "annotations": [] + }, + { + "name": "spacing", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "dampingCoefficient", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "9", + "annotations": [] + }, + { + "name": "enableScaling", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "children", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "widths", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mode", + "type": "LdMultiPanelLayoutMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "visibleStartIndex", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "visibleEndIndex", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onVisibleRangeChanged", + "type": "void Function(int, int)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "enableBorders", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mass", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "springConstant", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "dampingCoefficient", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "spacing", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "enableScaling", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/multi_panel/multi_panel_layout.dart", + "name": "_LdMultiPanelLayoutState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_positions", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isDragging", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragStartX", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragOffset", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_totalWidth", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_widths", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_layoutKey", + "type": "GlobalKey>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_dragFromLeft", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragFromRight", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdMultiPanelLayout", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_updateGestureExclusionRects", + "returnType": "void", + "signature": [ + { + "name": "availableWidth", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_clearGestureExclusionRects", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_initializePositions", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_nearNr", + "returnType": "bool", + "signature": [ + { + "name": "position", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "threshold", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onDragStart", + "returnType": "void", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragStartDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onDragUpdate", + "returnType": "void", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragUpdateDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onDragEnd", + "returnType": "void", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragEndDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_calculateLayout", + "returnType": "({List positions, List widths})", + "signature": [ + { + "name": "availableWidth", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "dragOffset", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildSideBySide", + "returnType": "Widget", + "signature": [ + { + "name": "targetPositions", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "widths", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "availableWidth", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildStacked", + "returnType": "Widget", + "signature": [ + { + "name": "availableWidth", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/multi_panel/multi_panel_layout.dart", + "name": "LdMultiPanelChildState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "left", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onScreen", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isDragging", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "dragOffset", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "left", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onScreen", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isDragging", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "dragOffset", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "of", + "returnType": "LdMultiPanelChildState", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "watch", + "returnType": "LdMultiPanelChildState", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/multi_panel/multi_panel_layout.dart", + "name": "extension", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "toStringHumanReadable", + "returnType": "dynamic", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "Rect", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/multi_panel/multi_panel_layout_mode.dart", + "name": "LdMultiPanelLayoutMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "sideBySide", + "type": "LdMultiPanelLayoutMode", + "description": " Children are placed side-by-side horizontally", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "stacked", + "type": "LdMultiPanelLayoutMode", + "description": " Children are stacked on top of each other", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/multi_panel/panel_width.dart", + "name": "PanelWidth", + "isNullSafe": true, + "description": " Configuration for panel width in LdMultiPanelLayout", + "constructors": [ + { + "name": "_", + "signature": [ + { + "name": "fixed", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "numerator", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "denominator", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isFill", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "fillFlex", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "fixed", + "signature": [ + { + "name": "width", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "fraction", + "signature": [ + { + "name": "numerator", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "denominator", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "half", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "third", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "twoThirds", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "quarter", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "threeQuarters", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "fill", + "signature": [ + { + "name": "fillFlex", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "_fixed", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_numerator", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_denominator", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_isFill", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_fillFlex", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isFixed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isFraction", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isFill", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fixedValue", + "type": "double?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fractionNumerator", + "type": "int?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fractionDenominator", + "type": "int?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fillFlex", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "calculateWidth", + "returnType": "double?", + "signature": [ + { + "name": "availableWidth", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "calculateSideBySideWidths", + "returnType": "(List, double)", + "signature": [ + { + "name": "widths", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "availableWidth", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "visibleStartIndex", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "visibleEndIndex", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "dragOffset", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "dragFromLeft", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "spacing", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Calculate actual width based on available space and other panels", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/time_picker.dart", + "name": "LdTimePicker", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "useRootNavigator", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "void Function(TimeOfDay?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buttonMode", + "description": "", + "type": "LdButtonMode", + "named": true, + "required": false, + "defaultValue": "LdButtonMode.filled", + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "TimeOfDay?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minutePrecision", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "15", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "useRootNavigator", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "value", + "type": "TimeOfDay?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "void Function(TimeOfDay?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "minutePrecision", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "buttonMode", + "type": "LdButtonMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/time_picker.dart", + "name": "LdTimePickerWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "initialTime", + "description": "", + "type": "TimeOfDay?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onTimeSelected", + "description": "", + "type": "void Function(TimeOfDay)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minutePrecision", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "15", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "minutePrecision", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialTime", + "type": "TimeOfDay?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onTimeSelected", + "type": "void Function(TimeOfDay)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/time_picker.dart", + "name": "_LdTimePickerWidgetState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_hourController", + "type": "FixedExtentScrollController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_minuteController", + "type": "FixedExtentScrollController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_hourFocusNode", + "type": "FocusScopeNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_hourControllerText", + "type": "TextEditingController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_minuteControllerText", + "type": "TextEditingController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_time", + "type": "TimeOfDay?", + "description": "", + "features": [ + "late" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdTimePickerWidget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_applyWheels", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_applyText", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_hourTextChanged", + "returnType": "void", + "signature": [ + { + "name": "newHour", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_minuteTextChanged", + "returnType": "void", + "signature": [ + { + "name": "newMinute", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_submit", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/radio.dart", + "name": "_LdRadioWidget", + "isNullSafe": true, + "description": " a radio box", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.s", + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "checked", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_onTap", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('success', defaults: {'color' : 'LdTheme.of(context).success'}), Variant('warning', defaults: {'color' : 'LdTheme.of(context).warning'}), Variant('error', defaults: {'color' : 'LdTheme.of(context).error'})])" + ], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/radio.dart", + "name": "LdRadio", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "checked", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "success", + "returnType": "Widget", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "warning", + "returnType": "Widget", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "error", + "returnType": "Widget", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/radio.dart", + "name": "LdRadioMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "primary", + "type": "LdRadioMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "warning", + "type": "LdRadioMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "error", + "type": "LdRadioMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/preview_wrapper.dart", + "name": "LiquidMultiPreview", + "isNullSafe": true, + "description": " Creates light and dark mode previews.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "previews", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "name", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "transform", + "returnType": "List", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "MultiPreview", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/preview_wrapper.dart", + "name": "wrapWidgetPreview", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "wrapWidgetPreview", + "returnType": "Widget", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/input_color.dart", + "name": "inputColor", + "isNullSafe": true, + "description": " Input surface mode - specialized for input fields with validation states", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "inputColor", + "returnType": "LdColorBundle", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isValid", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "onSurface", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Input surface mode - specialized for input fields with validation states", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/solid_color.dart", + "name": "solidColor", + "isNullSafe": true, + "description": " Solid surface mode - filled background with contrasting text", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "solidColor", + "returnType": "LdColorBundle", + "signature": [ + { + "name": "color", + "description": "", + "type": "LdColor", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Solid surface mode - filled background with contrasting text", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/outline_color.dart", + "name": "outlineColor", + "isNullSafe": true, + "description": " Outline surface mode - transparent background with colored text and border", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "outlineColor", + "returnType": "LdColorBundle", + "signature": [ + { + "name": "color", + "description": "", + "type": "LdColor", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Outline surface mode - transparent background with colored text and border", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/neutral_ghost_color.dart", + "name": "neutralGhostColor", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "neutralGhostColor", + "returnType": "LdColorBundle", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/ghost_color.dart", + "name": "ghostColor", + "isNullSafe": true, + "description": " Ghost surface mode - transparent background with colored text and border", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ghostColor", + "returnType": "LdColorBundle", + "signature": [ + { + "name": "color", + "description": "", + "type": "LdColor", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Ghost surface mode - transparent background with colored text and border", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/touchable.dart", + "name": "LdTouchableSurface", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "dynamic Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hitTestBehavior", + "description": "", + "type": "HitTestBehavior", + "named": true, + "required": false, + "defaultValue": "HitTestBehavior.opaque", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, LdColorBundle, LdTouchableStatus, Widget?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowTapOutside", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "isInput", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdTouchableSurfaceMode", + "named": true, + "required": false, + "defaultValue": "LdTouchableSurfaceMode.neutralGhost", + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "autoFocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "isOdd", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hitTestBehavior", + "type": "HitTestBehavior", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoFocus", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isOdd", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mode", + "type": "LdTouchableSurfaceMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "dynamic Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isInput", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowTapOutside", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, LdColorBundle, LdTouchableStatus, Widget?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/touchable.dart", + "name": "_LdTouchableSurfaceState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_hovering", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_pressed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_hasFocus", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_listenerKey", + "type": "GlobalKey>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_focusNode", + "type": "FocusNode?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_createdFocusNode", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_panOffset", + "type": "Offset?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "active", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdTouchableSurface", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_safeSetState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_colorBundle", + "returnType": "LdColorBundle", + "signature": [ + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/touchable.dart", + "name": "LdTouchableTouchFeedback", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "status", + "type": "LdTouchableStatus", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/touchable.dart", + "name": "LdTouchableSurfaceMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "ghost", + "type": "LdTouchableSurfaceMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "outline", + "type": "LdTouchableSurfaceMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "solid", + "type": "LdTouchableSurfaceMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "neutralGhost", + "type": "LdTouchableSurfaceMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "vague", + "type": "LdTouchableSurfaceMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "input", + "type": "LdTouchableSurfaceMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/touchable.dart", + "name": "touchableColor", + "isNullSafe": true, + "description": " Select the appropriate color for a touchable surface", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "touchableColor", + "returnType": "LdColorBundle", + "signature": [ + { + "name": "color", + "description": "", + "type": "LdColor", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mode", + "description": "", + "type": "LdTouchableSurfaceMode", + "named": true, + "required": false, + "defaultValue": "LdTouchableSurfaceMode.solid", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Select the appropriate color for a touchable surface", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/vague_color.dart", + "name": "vagueColor", + "isNullSafe": true, + "description": " Vague surface mode - subtle background with colored text and border", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "vagueColor", + "returnType": "LdColorBundle", + "signature": [ + { + "name": "color", + "description": "", + "type": "LdColor", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "status", + "description": "", + "type": "LdTouchableStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Vague surface mode - subtle background with colored text and border", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/touchable_colors.dart", + "name": "LdColorBundle", + "isNullSafe": true, + "description": " Current active colors", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "surface", + "description": "", + "type": "Color", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "text", + "description": "", + "type": "Color", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "border", + "description": "", + "type": "Color", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "placeholder", + "description": "", + "type": "Color", + "named": true, + "required": false, + "defaultValue": "Colors.transparent", + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + }, + { + "name": "autoText", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "surface", + "description": "", + "type": "Color", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "border", + "description": "", + "type": "Color", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "textColor", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "iconColor", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "placeholder", + "description": "", + "type": "Color", + "named": true, + "required": false, + "defaultValue": "Colors.transparent", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "surface", + "type": "Color", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "border", + "type": "Color", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "text", + "type": "Color", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "placeholder", + "type": "Color", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Color", + "description": "", + "features": [ + "late" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/touchable/touchable_status.dart", + "name": "LdTouchableStatus", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "hovering", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "focus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "pressed", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "panOffset", + "description": "", + "type": "Offset?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOdd", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "onSurface", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "hovering", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "focus", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "active", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "pressed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "panOffset", + "type": "Offset?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isOdd", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onSurface", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/accordion.dart", + "name": "LdAccordion", + "isNullSafe": true, + "description": " a collection of collapsible items in a group.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "childBuilder", + "description": "", + "type": "Widget Function(BuildContext, int)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "headerBuilder", + "description": "", + "type": "Widget Function(BuildContext, int)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "itemCount", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowMultipleOpen", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "childPadding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "headerPadding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialOpenIndex", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + }, + { + "name": "wrapActiveInCard", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "flatCard", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "speed", + "description": "", + "type": "Duration", + "named": true, + "required": false, + "defaultValue": "const Duration(milliseconds: 300)", + "annotations": [] + }, + { + "name": "shrinkWrap", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "single", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "headerPadding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "childPadding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "wrapActiveInCard", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "flatCard", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "allowMultipleOpen", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "header", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialOpen", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "fromList", + "signature": [ + { + "name": "items", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "wrapActiveInCard", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "flatCard", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "allowMultipleOpen", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialOpenIndex", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "childBuilder", + "type": "Widget Function(BuildContext, int)", + "description": " Function that is called to build each item in the accordion.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "headerBuilder", + "type": "Widget Function(BuildContext, int)", + "description": " Function that is called to build each header in the accordion.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "itemCount", + "type": "int", + "description": " The number of items in the accordion.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialOpenIndex", + "type": "Set", + "description": " The index of the items that should be open by default.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "headerPadding", + "type": "EdgeInsets?", + "description": " The padding to apply to the header.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "childPadding", + "type": "EdgeInsets?", + "description": " The padding to apply to the child.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowMultipleOpen", + "type": "bool", + "description": " Whether or not multiple items can be open at once.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "speed", + "type": "Duration", + "description": " The duration of the animation.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "wrapActiveInCard", + "type": "bool", + "description": " Whether or not to wrap the active item in a card.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "flatCard", + "type": "bool", + "description": " Whether or not to use a flat card.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shrinkWrap", + "type": "bool", + "description": " Whether or not to shrink the accordion to the content.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize?", + "description": " The size of the accordion.", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/accordion.dart", + "name": "LdAccordionItem", + "isNullSafe": true, + "description": " item of an accordion used in utility constructor [LdAccordion.fromList].", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "header", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "header", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/accordion.dart", + "name": "_LdAccordionChild", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "collapsed", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "wrapActiveInCard", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disableElevation", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "dynamic Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "headerPadding", + "description": "", + "type": "EdgeInsets", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "childPadding", + "description": "", + "type": "EdgeInsets", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "speed", + "description": "", + "type": "Duration", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "header", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "header", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "wrapActiveInCard", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "speed", + "type": "Duration", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "headerPadding", + "type": "EdgeInsets", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "childPadding", + "type": "EdgeInsets", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "dynamic Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "collapsed", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disableElevation", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/accordion.dart", + "name": "_LdAccordionState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "openIndex", + "type": "Set", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdAccordion", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_onTap", + "returnType": "void", + "signature": [ + { + "name": "n", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/avatar.dart", + "name": "_LdAvatarWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "circular", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [ + "@ContextConfigurable()" + ] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "circular", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('success', defaults: {'color' : 'LdTheme.of(context).success'}), Variant('warning', defaults: {'color' : 'LdTheme.of(context).warning'}), Variant('error', defaults: {'color' : 'LdTheme.of(context).error'})])" + ], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/avatar.dart", + "name": "LdAvatarConfig", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "circular", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/avatar.dart", + "name": "LdAvatarConfigProvider", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdAvatarConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "config", + "type": "LdAvatarConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/avatar.dart", + "name": "LdAvatar", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "circular", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "success", + "returnType": "Widget", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "warning", + "returnType": "Widget", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "error", + "returnType": "Widget", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "circular", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/date_picker.dart", + "name": "LdDatePicker", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "DateTime?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minDate", + "description": "", + "type": "DateTime?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxDate", + "description": "", + "type": "DateTime?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "displayFormat", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "\"yMd\"", + "annotations": [] + }, + { + "name": "buttonMode", + "description": "", + "type": "LdButtonMode", + "named": true, + "required": false, + "defaultValue": "LdButtonMode.filled", + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "void Function(DateTime?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "useRootNavigator", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "minDate", + "type": "DateTime?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxDate", + "type": "DateTime?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "value", + "type": "DateTime?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "displayFormat", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "buttonMode", + "type": "LdButtonMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "useRootNavigator", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "void Function(DateTime?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/date_picker.dart", + "name": "_LdDatePickerState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_selectedDateNotifier", + "type": "ValueNotifier", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_selectedDate", + "type": "DateTime", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_initialDate", + "type": "DateTime", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "initialDateJiffy", + "type": "Jiffy", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "initialDateString", + "type": "String", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdDatePicker", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/date_picker.dart", + "name": "_DatePickerSheet", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "selectedDateNotifier", + "description": "", + "type": "ValueNotifier", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minDate", + "description": "", + "type": "DateTime?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxDate", + "description": "", + "type": "DateTime?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectedDateNotifier", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "label", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "minDate", + "type": "DateTime?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxDate", + "type": "DateTime?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_DatePickerSheet>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/date_picker.dart", + "name": "_DatePickerSheetState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_pageController", + "type": "PageController?", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_animating", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_pageControllerIsValid", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_currentPage", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_viewDate", + "type": "DateTime", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showTodayButton", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "nextMonthIsValid", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "previousMonthIsValid", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_DatePickerSheet", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "monthSince0", + "returnType": "int", + "signature": [ + { + "name": "other", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_selectDate", + "returnType": "void", + "signature": [ + { + "name": "date", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "viewDate", + "returnType": "void", + "signature": [ + { + "name": "date", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildMonthSelect", + "returnType": "LdSelect", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildYearSelect", + "returnType": "LdSelect", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isSelected", + "returnType": "bool", + "signature": [ + { + "name": "date", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "containsValidDate", + "returnType": "bool", + "signature": [ + { + "name": "start", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "end", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isValidDate", + "returnType": "bool", + "signature": [ + { + "name": "date", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/date_picker.dart", + "name": "_MonthView", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "viewDate", + "description": "", + "type": "DateTime", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectedDate", + "description": "", + "type": "DateTime", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSelected", + "description": "", + "type": "void Function(DateTime)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minDate", + "description": "", + "type": "DateTime?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxDate", + "description": "", + "type": "DateTime?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "viewDate", + "type": "DateTime", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectedDate", + "type": "DateTime", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSelected", + "type": "void Function(DateTime)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "minDate", + "type": "DateTime?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxDate", + "type": "DateTime?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "isSameDay", + "returnType": "bool", + "signature": [ + { + "name": "date1", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "date2", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isToday", + "returnType": "bool", + "signature": [ + { + "name": "date", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isSelected", + "returnType": "bool", + "signature": [ + { + "name": "date", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isValidDate", + "returnType": "bool", + "signature": [ + { + "name": "date", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildWeekDayHeaders", + "returnType": "List", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buttonMode", + "returnType": "LdButtonMode", + "signature": [ + { + "name": "date", + "description": "", + "type": "DateTime", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/date_picker.dart", + "name": "extension", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "intersperse", + "returnType": "Iterable", + "signature": [ + { + "name": "element", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "Iterable", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/tag.dart", + "name": "_LdTagWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onDismiss", + "description": "", + "type": "Function?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onDismiss", + "type": "Function?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_padding", + "returnType": "double", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_fontSize", + "returnType": "double", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('success', defaults: {'color' : 'LdTheme.of(context).success'}), Variant('warning', defaults: {'color' : 'LdTheme.of(context).warning'}), Variant('error', defaults: {'color' : 'LdTheme.of(context).error'})])" + ], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/tag.dart", + "name": "LdTag", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onDismiss", + "description": "", + "type": "Function?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onDismiss", + "type": "Function?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "success", + "returnType": "Widget", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onDismiss", + "description": "", + "type": "Function?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "warning", + "returnType": "Widget", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onDismiss", + "description": "", + "type": "Function?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "error", + "returnType": "Widget", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onDismiss", + "description": "", + "type": "Function?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/context_menu.dart", + "name": "LdContextMenuDissmissNotification", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [], + "methods": [ + { + "name": "dispatch", + "returnType": "void", + "signature": [ + { + "name": "target", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Start bubbling this notification at the given build context.\n\n The notification will be delivered to any [NotificationListener] widgets\n with the appropriate type parameters that are ancestors of the given\n [BuildContext]. If the [BuildContext] is null, the notification is not\n dispatched.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugFillDescription", + "returnType": "void", + "signature": [ + { + "name": "description", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional information to the given description for use by [toString].\n\n This method makes it easier for subclasses to coordinate to provide a\n high-quality [toString] implementation. The [toString] implementation on\n the [Notification] base class calls [debugFillDescription] to collect\n useful information from subclasses to incorporate into its return value.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.debugFillDescription(description)`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Notification", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/context_menu.dart", + "name": "LdContextMenu", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, bool, void Function(), bool, Widget?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "menuBuilder", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "dismissOnOutsideTap", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "placeAboveTrigger", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "inheritTriggerWidth", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "scaleFromTrigger", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "blurMode", + "description": "", + "type": "LdContextMenuBlurMode", + "named": true, + "required": false, + "defaultValue": "LdContextMenuBlurMode.mobileOnly", + "annotations": [] + }, + { + "name": "zoomMode", + "description": "", + "type": "LdContextZoomMode", + "named": true, + "required": false, + "defaultValue": "LdContextZoomMode.mobileOnly", + "annotations": [] + }, + { + "name": "listenForTaps", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "visible", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "positionMode", + "description": "", + "type": "LdContextPositionMode", + "named": true, + "required": false, + "defaultValue": "LdContextPositionMode.auto", + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "triggerColor", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "menuProviders", + "description": "", + "type": "List? Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "visible", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "placeAboveTrigger", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "dismissOnOutsideTap", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "inheritTriggerWidth", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "triggerColor", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "listenForTaps", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scaleFromTrigger", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "menuProviders", + "type": "List? Function(BuildContext)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "blurMode", + "type": "LdContextMenuBlurMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "zoomMode", + "type": "LdContextZoomMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "positionMode", + "type": "LdContextPositionMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, bool, void Function(), bool, Widget?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "menuBuilder", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/context_menu.dart", + "name": "LdContextMenuState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_triggerKey", + "type": "GlobalKey>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_triggerBox", + "type": "RenderBox?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_cursorPosition", + "type": "Offset?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_menuSizeNotifier", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_isOpen", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_mobile", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_shouldBlur", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_shouldZoom", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_effectivePositionMode", + "type": "LdContextPositionMode", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdContextMenu", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_getTriggerPosition", + "returnType": "Offset?", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getTriggerSize", + "returnType": "Size?", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "open", + "returnType": "void", + "signature": [ + { + "name": "globalPosition", + "description": "", + "type": "Offset?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildTriggerDetector", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/context_menu.dart", + "name": "LdContextMenuRoute", + "isNullSafe": true, + "description": " A modal route for displaying a context menu, supporting custom positioning, blur, and zoom.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "menuBuilder", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "effectivePositionMode", + "description": "", + "type": "LdContextPositionMode", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "cursorPosition", + "description": "", + "type": "Offset?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "placeAboveTrigger", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "shouldBlur", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "shouldZoom", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "backgroundColor", + "description": "", + "type": "Color?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onDismiss", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "triggerPosition", + "description": "", + "type": "Offset", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "triggerSize", + "description": "", + "type": "Size", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "providers", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "triggerKey", + "description": "", + "type": "GlobalKey>", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "triggerBuilder", + "description": "", + "type": "Widget Function(BuildContext, bool, void Function(), Widget?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inheritTriggerWidth", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "filter", + "type": "ImageFilter?", + "description": " The filter to add to the barrier.\n\n If given, this filter will be applied to the modal barrier using\n [BackdropFilter]. This allows blur effects, for example.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "traversalEdgeBehavior", + "type": "TraversalEdgeBehavior?", + "description": " Controls the transfer of focus beyond the first and the last items of a\n [FocusScopeNode].\n\n If set to null, [Navigator.routeTraversalEdgeBehavior] is used.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "directionalTraversalEdgeBehavior", + "type": "TraversalEdgeBehavior?", + "description": " Controls the directional transfer of focus beyond the first and the last\n items of a [FocusScopeNode].\n\n If set to null, [Navigator.routeDirectionalTraversalEdgeBehavior] is used.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "receivedTransition", + "type": "Widget? Function(BuildContext, Animation, Animation, bool, Widget?)?", + "description": " The [DelegatedTransitionBuilder] received from the route above this one in\n the navigation stack.\n\n {@macro flutter.widgets.delegatedTransition}\n\n The `receivedTransition` will use the above route's [delegatedTransition] in\n order to show the right route transition when the above route either enters\n or leaves the navigation stack. If not null, the `receivedTransition` will\n wrap the route content.", + "features": [], + "annotations": [ + "@visibleForTesting" + ] + }, + { + "name": "_offstage", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_animationProxy", + "type": "ProxyAnimation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_secondaryAnimationProxy", + "type": "ProxyAnimation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_willPopCallbacks", + "type": "List Function()>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_popEntries", + "type": "Set>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_scopeKey", + "type": "GlobalKey<_ModalScopeState>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_subtreeKey", + "type": "GlobalKey>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_storageBucket", + "type": "PageStorageBucket", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_modalBarrier", + "type": "OverlayEntry", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_modalScopeCache", + "type": "Widget?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_modalScope", + "type": "OverlayEntry", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "delegatedTransition", + "type": "Widget? Function(BuildContext, Animation, Animation, bool, Widget?)?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "barrierDismissible", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "semanticsDismissible", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "barrierColor", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "barrierLabel", + "type": "String?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "barrierCurve", + "type": "Curve", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "maintainState", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "popGestureInProgress", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "popGestureEnabled", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "offstage", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "subtreeContext", + "type": "BuildContext?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "animation", + "type": "Animation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "secondaryAnimation", + "type": "Animation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "popDisposition", + "type": "RoutePopDisposition", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasScopedWillPopCallback", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "canPop", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "impliesAppBarDismissal", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fullscreenDialog", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_transitionCompleter", + "type": "Completer", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_performanceModeRequestHandle", + "type": "PerformanceModeRequestHandle?", + "description": " Handle to the performance mode request.\n\n When the route is animating, the performance mode is requested. It is then\n disposed when the animation ends. Requesting [DartPerformanceMode.latency]\n indicates to the engine that the transition is latency sensitive and to delay\n non-essential work while this handle is active.", + "features": [], + "annotations": [] + }, + { + "name": "_popFinalized", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_animation", + "type": "Animation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_controller", + "type": "AnimationController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_secondaryAnimation", + "type": "ProxyAnimation", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "willDisposeAnimationController", + "type": "bool", + "description": " Whether to takeover the [controller] created by [createAnimationController].\n\n If true, this route will call [AnimationController.dispose] when the\n controller is no longer needed.\n If false, the controller should be disposed by whoever owned it.\n\n It defaults to `true`.", + "features": [], + "annotations": [] + }, + { + "name": "_simulation", + "type": "Simulation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_result", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_trainHoppingListenerRemover", + "type": "void Function()?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "completed", + "type": "Future", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "transitionDuration", + "type": "Duration", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "reverseTransitionDuration", + "type": "Duration", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "opaque", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "allowSnapshotting", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "finishedWhenPopped", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "controller", + "type": "AnimationController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugLabel", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_overlayEntries", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "overlayEntries", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_requestFocus", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_navigator", + "type": "NavigatorState?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_settings", + "type": "RouteSettings", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_restorationScopeId", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_popCompleter", + "type": "Completer", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_disposeCompleter", + "type": "Completer", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "requestFocus", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "navigator", + "type": "NavigatorState?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "settings", + "type": "RouteSettings", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isPageBased", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "restorationScopeId", + "type": "ValueListenable", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "willHandlePopInternally", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "currentResult", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "popped", + "type": "Future", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isCurrent", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isFirst", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasActiveRouteBelow", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isActive", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_localHistory", + "type": "List?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_entriesImpliesAppBarDismissal", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "menuBuilder", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "triggerPosition", + "type": "Offset", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "triggerKey", + "type": "GlobalKey>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "inheritTriggerWidth", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "triggerSize", + "type": "Size", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shouldBlur", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "effectivePositionMode", + "type": "LdContextPositionMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "cursorPosition", + "type": "Offset?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shouldZoom", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "backgroundColor", + "type": "Color?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onDismiss", + "type": "void Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "providers", + "type": "List?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "triggerBuilder", + "type": "Widget Function(BuildContext, bool, void Function(), Widget?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "placeAboveTrigger", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_menuSizeNotifier", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Schedule a call to [buildTransitions].\n\n Whenever you need to change internal state for a [ModalRoute] object, make\n the change in a function that you pass to [setState], as in:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n If you just change the state directly without calling [setState], then the\n route will not be scheduled for rebuilding, meaning that its rendering\n will not be updated.", + "annotations": [ + "@protected" + ] + }, + { + "name": "buildPage", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAnimation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "buildTransitions", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAnimation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_buildFlexibleTransitions", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAnimation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "install", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the route is inserted into the navigator.\n\n Uses this to populate [overlayEntries]. There must be at least one entry in\n this list after [install] has been invoked. The [Navigator] will be in charge\n to add them to the [Overlay] or remove them from it by calling\n [OverlayEntry.remove].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didPush", + "returnType": "TickerFuture", + "signature": [], + "features": [], + "description": " Called after [install] when the route is pushed onto the navigator.\n\n The returned value resolves when the push transition is complete.\n\n The [didAdd] method will be called instead of [didPush] when the route\n immediately appears on screen without any push transition.\n\n The [didChangeNext] and [didChangePrevious] methods are typically called\n immediately after this method is called.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didAdd", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called after [install] when the route is added to the navigator.\n\n This method is called instead of [didPush] when the route immediately\n appears on screen without any push transition.\n\n The [didChangeNext] and [didChangePrevious] methods are typically called\n immediately after this method is called.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "willPop", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@Deprecated('Use popDisposition instead. ' 'This feature was deprecated after v3.12.0-1.0.pre.')", + "@override" + ] + }, + { + "name": "onPopInvokedWithResult", + "returnType": "void", + "signature": [ + { + "name": "didPop", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "result", + "description": "", + "type": "void", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " {@template flutter.widgets.navigator.onPopInvokedWithResult}\n Called after a route pop was handled.\n\n Even when the pop is canceled, for example by a [PopScope] widget, this\n will still be called. The `didPop` parameter indicates whether or not the\n back navigation actually happened successfully.\n {@endtemplate}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "addScopedWillPopCallback", + "returnType": "void", + "signature": [ + { + "name": "callback", + "description": "", + "type": "Future Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Enables this route to veto attempts by the user to dismiss it.\n\n This callback runs asynchronously and it's possible that it will be called\n after its route has been disposed. The callback should check [State.mounted]\n before doing anything.\n\n A typical application of this callback would be to warn the user about\n unsaved [Form] data if the user attempts to back out of the form. In that\n case, use the [Form.onWillPop] property to register the callback.\n\n See also:\n\n * [WillPopScope], which manages the registration and unregistration\n process automatically.\n * [Form], which provides an `onWillPop` callback that uses this mechanism.\n * [willPop], which runs the callbacks added with this method.\n * [removeScopedWillPopCallback], which removes a callback from the list\n that [willPop] checks.", + "annotations": [ + "@Deprecated('Use registerPopEntry or PopScope instead. ' 'This feature was deprecated after v3.12.0-1.0.pre.')" + ] + }, + { + "name": "removeScopedWillPopCallback", + "returnType": "void", + "signature": [ + { + "name": "callback", + "description": "", + "type": "Future Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove one of the callbacks run by [willPop].\n\n See also:\n\n * [Form], which provides an `onWillPop` callback that uses this mechanism.\n * [addScopedWillPopCallback], which adds callback to the list\n checked by [willPop].", + "annotations": [ + "@Deprecated('Use unregisterPopEntry or PopScope instead. ' 'This feature was deprecated after v3.12.0-1.0.pre.')" + ] + }, + { + "name": "registerPopEntry", + "returnType": "void", + "signature": [ + { + "name": "popEntry", + "description": "", + "type": "PopEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Registers the existence of a [PopEntry] in the route.\n\n [PopEntry] instances registered in this way will have their\n [PopEntry.onPopInvokedWithResult] callbacks called when a route is popped or a pop\n is attempted. They will also be able to block pop operations with\n [PopEntry.canPopNotifier] through this route's [popDisposition] method.\n\n See also:\n\n * [unregisterPopEntry], which performs the opposite operation.", + "annotations": [] + }, + { + "name": "unregisterPopEntry", + "returnType": "void", + "signature": [ + { + "name": "popEntry", + "description": "", + "type": "PopEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Unregisters a [PopEntry] in the route's widget subtree.\n\n See also:\n\n * [registerPopEntry], which performs the opposite operation.", + "annotations": [] + }, + { + "name": "_maybeDispatchNavigationNotification", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "didChangePrevious", + "returnType": "void", + "signature": [ + { + "name": "previousRoute", + "description": "", + "type": "Route?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " This route's previous route has changed to the given new route.\n\n This is called on a route whenever the previous route changes for any\n reason, so long as it is in the history, except for immediately after the\n route itself has been pushed (in which case [didPush] or [didReplace] will\n be called instead).\n\n The `previousRoute` argument will be null if there's no previous route\n (i.e. if [isFirst] is true).", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didChangeNext", + "returnType": "void", + "signature": [ + { + "name": "nextRoute", + "description": "", + "type": "Route?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " This route's next route has changed to the given new route.\n\n This is called on a route whenever the next route changes for any reason,\n so long as it is in the history, including when a route is first added to\n a [Navigator] (e.g. by [Navigator.push]), except for cases when\n [didPopNext] would be called.\n\n The `nextRoute` argument will be null if there's no new next route (i.e.\n if [isCurrent] is true).", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didPopNext", + "returnType": "void", + "signature": [ + { + "name": "nextRoute", + "description": "", + "type": "Route", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " The given route, which was above this one, has been popped off the\n navigator.\n\n This route is now the current route ([isCurrent] is now true), and there\n is no next route.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "changedInternalState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called whenever the internal state of the route has changed.\n\n This should be called whenever [willHandlePopInternally], [didPop],\n [ModalRoute.offstage], or other internal state of the route changes value.\n It is used by [ModalRoute], for example, to report the new information via\n its inherited widget to any children of the route.\n\n See also:\n\n * [changedExternalState], which is called when the [Navigator] has\n updated in some manner that might affect the routes.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "changedExternalState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called whenever the [Navigator] has updated in some manner that might\n affect routes, to indicate that the route may wish to rebuild as well.\n\n This is called by the [Navigator] whenever the\n [NavigatorState]'s [State.widget] changes (as in [State.didUpdateWidget]),\n for example because the [MaterialApp] has been rebuilt. This\n ensures that routes that directly refer to the state of the\n widget that built the [MaterialApp] will be notified when that\n widget rebuilds, since it would otherwise be difficult to notify\n the routes that state they depend on may have changed.\n\n It is also called whenever the [Navigator]'s dependencies change\n (as in [State.didChangeDependencies]). This allows routes to use the\n [Navigator]'s context ([NavigatorState.context]), for example in\n [ModalRoute.barrierColor], and update accordingly.\n\n The [ModalRoute] subclass overrides this to force the barrier\n overlay to rebuild.\n\n See also:\n\n * [changedInternalState], the equivalent but for changes to the internal\n state of the route.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "_buildModalBarrier", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "buildModalBarrier", + "returnType": "Widget", + "signature": [], + "features": [], + "description": " Build the barrier for this [ModalRoute], subclasses can override\n this method to create their own barrier with customized features such as\n color or accessibility focus size.\n\n See also:\n * [ModalBarrier], which is typically used to build a barrier.\n * [ModalBottomSheetRoute], which overrides this method to build a\n customized barrier.", + "annotations": [] + }, + { + "name": "_buildModalScope", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "createOverlayEntries", + "returnType": "Iterable", + "signature": [], + "features": [ + "abstract" + ], + "description": " Subclasses should override this getter to return the builders for the overlay.", + "annotations": [ + "@factory" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugTransitionCompleted", + "returnType": "bool", + "signature": [], + "features": [], + "description": " Returns true if the transition has completed.\n\n It is equivalent to whether the future returned by [completed] has\n completed.\n\n This method only works if assert is enabled. Otherwise it always returns\n false.", + "annotations": [ + "@protected" + ] + }, + { + "name": "createAnimationController", + "returnType": "AnimationController", + "signature": [], + "features": [], + "description": " Called to create the animation controller that will drive the transitions to\n this route from the previous one, and back to the previous route from this\n one.\n\n The returned controller will be disposed by [AnimationController.dispose]\n if the [willDisposeAnimationController] is `true`.", + "annotations": [] + }, + { + "name": "createAnimation", + "returnType": "Animation", + "signature": [], + "features": [], + "description": " Called to create the animation that exposes the current progress of\n the transition controlled by the animation controller created by\n [createAnimationController()].", + "annotations": [] + }, + { + "name": "createSimulation", + "returnType": "Simulation?", + "signature": [ + { + "name": "forward", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Creates the simulation that drives the transition animation for this route.\n\n By default, this method returns null, indicating that the route doesn't\n use simulations, but initiates the transition by calling either\n [AnimationController.forward] or [AnimationController.reverse] with\n [transitionDuration] and the controller's curve.\n\n Subclasses can override this method to return a non-null [Simulation]. In\n this case, the [controller] will instead use the provided simulation to\n animate the transition using [AnimationController.animateWith] or\n [AnimationController.animateBackWith], and the [Simulation.x] is forwarded\n to the value of [animation]. The [controller]'s curve and\n [transitionDuration] are ignored.\n\n This method is invoked each time the navigator pushes or pops this route.\n The `forward` parameter indicates the direction of the transition: true when\n the route is pushed, and false when it is popped.", + "annotations": [] + }, + { + "name": "_createSimulationAndVerify", + "returnType": "Simulation?", + "signature": [ + { + "name": "forward", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_handleStatusChanged", + "returnType": "void", + "signature": [ + { + "name": "status", + "description": "", + "type": "AnimationStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "didReplace", + "returnType": "void", + "signature": [ + { + "name": "oldRoute", + "description": "", + "type": "Route?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called after [install] when the route replaced another in the navigator.\n\n The [didChangeNext] and [didChangePrevious] methods are typically called\n immediately after this method is called.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didPop", + "returnType": "bool", + "signature": [ + { + "name": "result", + "description": "", + "type": "void", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_updateSecondaryAnimation", + "returnType": "void", + "signature": [ + { + "name": "nextRoute", + "description": "", + "type": "Route?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_setSecondaryAnimation", + "returnType": "void", + "signature": [ + { + "name": "animation", + "description": "", + "type": "Animation?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disposed", + "description": "", + "type": "Future?", + "named": false, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "canTransitionTo", + "returnType": "bool", + "signature": [ + { + "name": "nextRoute", + "description": "", + "type": "TransitionRoute", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns true if this route supports a transition animation that runs\n when [nextRoute] is pushed on top of it or when [nextRoute] is popped\n off of it.\n\n Subclasses can override this method to restrict the set of routes they\n need to coordinate transitions with.\n\n If true, and `nextRoute.canTransitionFrom()` is true, then the\n [ModalRoute.buildTransitions] `secondaryAnimation` will run from 0.0 - 1.0\n when [nextRoute] is pushed on top of this one. Similarly, if\n the [nextRoute] is popped off of this route, the\n `secondaryAnimation` will run from 1.0 - 0.0.\n\n If false, this route's [ModalRoute.buildTransitions] `secondaryAnimation` parameter\n value will be [kAlwaysDismissedAnimation]. In other words, this route\n will not animate when [nextRoute] is pushed on top of it or when\n [nextRoute] is popped off of it.\n\n Returns true by default.\n\n See also:\n\n * [canTransitionFrom], which must be true for [nextRoute] for the\n [ModalRoute.buildTransitions] `secondaryAnimation` to run.", + "annotations": [] + }, + { + "name": "canTransitionFrom", + "returnType": "bool", + "signature": [ + { + "name": "previousRoute", + "description": "", + "type": "TransitionRoute", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns true if [previousRoute] should animate when this route\n is pushed on top of it or when then this route is popped off of it.\n\n Subclasses can override this method to restrict the set of routes they\n need to coordinate transitions with.\n\n If true, and `previousRoute.canTransitionTo()` is true, then the\n previous route's [ModalRoute.buildTransitions] `secondaryAnimation` will\n run from 0.0 - 1.0 when this route is pushed on top of\n it. Similarly, if this route is popped off of [previousRoute]\n the previous route's `secondaryAnimation` will run from 1.0 - 0.0.\n\n If false, then the previous route's [ModalRoute.buildTransitions]\n `secondaryAnimation` value will be kAlwaysDismissedAnimation. In\n other words [previousRoute] will not animate when this route is\n pushed on top of it or when then this route is popped off of it.\n\n Returns true by default.\n\n See also:\n\n * [canTransitionTo], which must be true for [previousRoute] for its\n [ModalRoute.buildTransitions] `secondaryAnimation` to run.", + "annotations": [] + }, + { + "name": "handleStartBackGesture", + "returnType": "void", + "signature": [ + { + "name": "progress", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0.0", + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Handles a predictive back gesture starting.\n\n The `progress` parameter indicates the progress of the gesture from 0.0 to\n 1.0, as in [PredictiveBackEvent.progress].", + "annotations": [] + }, + { + "name": "handleUpdateBackGestureProgress", + "returnType": "void", + "signature": [ + { + "name": "progress", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Handles a predictive back gesture updating as the user drags across the\n screen.\n\n The `progress` parameter indicates the progress of the gesture from 0.0 to\n 1.0, as in [PredictiveBackEvent.progress].", + "annotations": [] + }, + { + "name": "handleCancelBackGesture", + "returnType": "void", + "signature": [], + "features": [ + "abstract" + ], + "description": " Handles a predictive back gesture ending in cancellation.", + "annotations": [] + }, + { + "name": "handleCommitBackGesture", + "returnType": "void", + "signature": [], + "features": [ + "abstract" + ], + "description": " Handles a predictive back gesture ending successfully.", + "annotations": [] + }, + { + "name": "_handleDragEnd", + "returnType": "void", + "signature": [ + { + "name": "animateForward", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_updateSettings", + "returnType": "void", + "signature": [ + { + "name": "newSettings", + "description": "", + "type": "RouteSettings", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateRestorationId", + "returnType": "void", + "signature": [ + { + "name": "restorationId", + "description": "", + "type": "String?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "onPopInvoked", + "returnType": "void", + "signature": [ + { + "name": "didPop", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called after a route pop was handled.\n\n Even when the pop is canceled, for example by a [PopScope] widget, this\n will still be called. The `didPop` parameter indicates whether or not the\n back navigation actually happened successfully.", + "annotations": [ + "@Deprecated('Override onPopInvokedWithResult instead. ' 'This feature was deprecated after v3.22.0-12.0.pre.')" + ] + }, + { + "name": "didComplete", + "returnType": "void", + "signature": [ + { + "name": "result", + "description": "", + "type": "void", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "addLocalHistoryEntry", + "returnType": "void", + "signature": [ + { + "name": "entry", + "description": "", + "type": "LocalHistoryEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Adds a local history entry to this route.\n\n When asked to pop, if this route has any local history entries, this route\n will handle the pop internally by removing the most recently added local\n history entry.\n\n The given local history entry must not already be part of another local\n history route.\n\n {@tool snippet}\n\n The following example is an app with 2 pages: `HomePage` and `SecondPage`.\n The `HomePage` can navigate to the `SecondPage`.\n\n The `SecondPage` uses a [LocalHistoryEntry] to implement local navigation\n within that page. Pressing 'show rectangle' displays a red rectangle and\n adds a local history entry. At that point, pressing the '< back' button\n pops the latest route, which is the local history entry, and the red\n rectangle disappears. Pressing the '< back' button a second time\n once again pops the latest route, which is the `SecondPage`, itself.\n Therefore, the second press navigates back to the `HomePage`.\n\n ```dart\n class App extends StatelessWidget {\n const App({super.key});\n\n @override\n Widget build(BuildContext context) {\n return MaterialApp(\n initialRoute: '/',\n routes: {\n '/': (BuildContext context) => const HomePage(),\n '/second_page': (BuildContext context) => const SecondPage(),\n },\n );\n }\n }\n\n class HomePage extends StatefulWidget {\n const HomePage({super.key});\n\n @override\n State createState() => _HomePageState();\n }\n\n class _HomePageState extends State {\n @override\n Widget build(BuildContext context) {\n return Scaffold(\n body: Center(\n child: Column(\n mainAxisSize: MainAxisSize.min,\n children: [\n const Text('HomePage'),\n // Press this button to open the SecondPage.\n ElevatedButton(\n child: const Text('Second Page >'),\n onPressed: () {\n Navigator.pushNamed(context, '/second_page');\n },\n ),\n ],\n ),\n ),\n );\n }\n }\n\n class SecondPage extends StatefulWidget {\n const SecondPage({super.key});\n\n @override\n State createState() => _SecondPageState();\n }\n\n class _SecondPageState extends State {\n\n bool _showRectangle = false;\n\n Future _navigateLocallyToShowRectangle() async {\n // This local history entry essentially represents the display of the red\n // rectangle. When this local history entry is removed, we hide the red\n // rectangle.\n setState(() => _showRectangle = true);\n ModalRoute.of(context)?.addLocalHistoryEntry(\n LocalHistoryEntry(\n onRemove: () {\n // Hide the red rectangle.\n setState(() => _showRectangle = false);\n }\n )\n );\n }\n\n @override\n Widget build(BuildContext context) {\n final Widget localNavContent = _showRectangle\n ? Container(\n width: 100.0,\n height: 100.0,\n color: Colors.red,\n )\n : ElevatedButton(\n onPressed: _navigateLocallyToShowRectangle,\n child: const Text('Show Rectangle'),\n );\n\n return Scaffold(\n body: Center(\n child: Column(\n mainAxisAlignment: MainAxisAlignment.center,\n children: [\n localNavContent,\n ElevatedButton(\n child: const Text('< Back'),\n onPressed: () {\n // Pop a route. If this is pressed while the red rectangle is\n // visible then it will pop our local history entry, which\n // will hide the red rectangle. Otherwise, the SecondPage will\n // navigate back to the HomePage.\n Navigator.of(context).pop();\n },\n ),\n ],\n ),\n ),\n );\n }\n }\n ```\n {@end-tool}", + "annotations": [] + }, + { + "name": "removeLocalHistoryEntry", + "returnType": "void", + "signature": [ + { + "name": "entry", + "description": "", + "type": "LocalHistoryEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove a local history entry from this route.\n\n The entry's [LocalHistoryEntry.onRemove] callback, if any, will be called\n synchronously.", + "annotations": [] + }, + { + "name": "_resizeMenuToScreen", + "returnType": "(Rect, Alignment, Size)", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "menuSize", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildOffstageMenuForMeasurement", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildAnimatedMenuTransition", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "menuSize", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animation", + "description": "", + "type": "Animation?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getMenuOffset", + "returnType": "Offset", + "signature": [ + { + "name": "alignment", + "description": "", + "type": "Alignment", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_wrapMenuDecoration", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "Alignment", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxConstraints", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_wrapMenuContent", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "menu", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "alignment", + "description": "", + "type": "Alignment", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxConstraints", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isAnimating", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_wrapWithProviders", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "ModalRoute", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/context_menu.dart", + "name": "LdContextMenuBlurMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "mobileOnly", + "type": "LdContextMenuBlurMode", + "description": " Blur on mobile", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "always", + "type": "LdContextMenuBlurMode", + "description": " Always blur", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "never", + "type": "LdContextMenuBlurMode", + "description": " Never blur", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/context_menu.dart", + "name": "LdContextZoomMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "mobileOnly", + "type": "LdContextZoomMode", + "description": " Zoom on mobile", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "always", + "type": "LdContextZoomMode", + "description": " Always zoom", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "never", + "type": "LdContextZoomMode", + "description": " Never zoom", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/context_menu.dart", + "name": "LdContextPositionMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "auto", + "type": "LdContextPositionMode", + "description": " Automatically position the menu uses [relativeTrigger] on mobile and [relativeCursor] on desktop", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "relativeTrigger", + "type": "LdContextPositionMode", + "description": " Position relative to the trigger", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "relativeCursor", + "type": "LdContextPositionMode", + "description": " Position relative to the cursor", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/context_menu.dart", + "name": "maybePopContextMenu", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "maybePopContextMenu", + "returnType": "Future", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/table.dart", + "name": "LdCol", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "title", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "sort", + "description": "", + "type": "int Function(T, T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "weight", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "title", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sort", + "type": "int Function(T, T)?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "weight", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/table.dart", + "name": "LdTable", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "columns", + "description": "", + "type": "List>", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "rows", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildRow", + "description": "", + "type": "List Function(T)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSelectionChanged", + "description": "", + "type": "dynamic Function(T, bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectedRows", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + }, + { + "name": "header", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowSort", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "rowCount", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "density", + "description": "", + "type": "LdTableDensity", + "named": true, + "required": false, + "defaultValue": "LdTableDensity.normal", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "columns", + "type": "List>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "rows", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "buildRow", + "type": "List Function(T)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSelectionChanged", + "type": "dynamic Function(T, bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectedRows", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowSort", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "header", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "rowCount", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "density", + "type": "LdTableDensity", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/table.dart", + "name": "_LdTableState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "width", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_sortByCol", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_sortDir", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_sortedRows", + "type": "List", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_rowPadding", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_checkboxSize", + "type": "LdSize", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectable", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdTable", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_resort", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_colWidth", + "returnType": "double", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/table.dart", + "name": "LdTableDensity", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "compact", + "type": "LdTableDensity", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "normal", + "type": "LdTableDensity", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "relaxed", + "type": "LdTableDensity", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "squeezed", + "type": "LdTableDensity", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/shrinkwrap_pageview.dart", + "name": "ExpandablePageView", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "itemBuilder", + "description": "", + "type": "Widget Function(BuildContext, int)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "PageController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPageChanged", + "description": "", + "type": "void Function(int)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "reverse", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "itemBuilder", + "type": "Widget Function(BuildContext, int)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "controller", + "type": "PageController?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPageChanged", + "type": "void Function(int)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "reverse", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "_ExpandablePageViewState", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/shrinkwrap_pageview.dart", + "name": "_ExpandablePageViewState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_pageController", + "type": "PageController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_heights", + "type": "Map", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_currentPage", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_currentHeight", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "ExpandablePageView", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_onSizeChange", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "height", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_itemBuilder", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updatePage", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/spring.dart", + "name": "LdSpringState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "position", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "force", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "velocity", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isMoving", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "position", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "force", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "velocity", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isMoving", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/spring.dart", + "name": "LdSpring", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mass", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "5", + "annotations": [] + }, + { + "name": "springConstant", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "10", + "annotations": [] + }, + { + "name": "dampingCoefficient", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "9", + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, LdSpringState, Widget?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "paused", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1.0", + "annotations": [] + }, + { + "name": "initialPosition", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1.0", + "annotations": [] + }, + { + "name": "onAnimationEnd", + "description": "", + "type": "void Function(BuildContext, LdSpringState)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mass", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "springConstant", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "dampingCoefficient", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "position", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialPosition", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "paused", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onAnimationEnd", + "type": "void Function(BuildContext, LdSpringState)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, LdSpringState, Widget?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/spring.dart", + "name": "_Spring", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "springConstant", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "10", + "annotations": [] + }, + { + "name": "dampingCoefficient", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "9", + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1.0", + "annotations": [] + }, + { + "name": "targetPosition", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1.0", + "annotations": [] + }, + { + "name": "mass", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "5", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "timeStep", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "springConstant", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "dampingCoefficient", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mass", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "targetPosition", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "position", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "velocity", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "acceleration", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "oneFrameElapsed", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "springForce", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "dampingForce", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "force", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "state", + "type": "LdSpringState", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "update", + "returnType": "void", + "signature": [ + { + "name": "elapsedMs", + "description": "", + "type": "int?", + "named": false, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/spring.dart", + "name": "_LdSpringState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_ticker", + "type": "Ticker?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickerModeNotifier", + "type": "ValueListenable?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_spring", + "type": "_Spring", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdSpring", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "createTicker", + "returnType": "Ticker", + "signature": [ + { + "name": "onTick", + "description": "", + "type": "void Function(Duration)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Creates a ticker with the given callback.\n\n The kind of ticker provided depends on the kind of ticker provider.", + "annotations": [ + "@factory" + ] + }, + { + "name": "_updateTicker", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickerModeNotifier", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "update", + "returnType": "void", + "signature": [ + { + "name": "elapsedTime", + "description": "", + "type": "int?", + "named": false, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "SingleTickerProviderStateMixin" + ] + }, + { + "filePath": "lib/src/spring.dart", + "name": "LdChainedSprings", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "count", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "5", + "annotations": [] + }, + { + "name": "mass", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "5", + "annotations": [] + }, + { + "name": "springConstant", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "10", + "annotations": [] + }, + { + "name": "dampingCoefficient", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "9", + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, List, Widget?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "reversed", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "initialPosition", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1.0", + "annotations": [] + }, + { + "name": "targetPosition", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1.0", + "annotations": [] + }, + { + "name": "onAnimationEnd", + "description": "", + "type": "dynamic Function(BuildContext, List)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "count", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mass", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "springConstant", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "dampingCoefficient", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialPosition", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "targetPosition", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "reversed", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onAnimationEnd", + "type": "dynamic Function(BuildContext, List)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, List, Widget?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/spring.dart", + "name": "_LdChainedSpringsState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_ticker", + "type": "Ticker?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickerModeNotifier", + "type": "ValueListenable?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_springs", + "type": "List<_Spring>", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdChainedSprings", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "createTicker", + "returnType": "Ticker", + "signature": [ + { + "name": "onTick", + "description": "", + "type": "void Function(Duration)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Creates a ticker with the given callback.\n\n The kind of ticker provided depends on the kind of ticker provider.", + "annotations": [ + "@factory" + ] + }, + { + "name": "_updateTicker", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickerModeNotifier", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_createSprings", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "update", + "returnType": "void", + "signature": [ + { + "name": "elapsedMs", + "description": "", + "type": "int?", + "named": false, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "SingleTickerProviderStateMixin" + ] + }, + { + "filePath": "lib/src/speed_reader.dart", + "name": "Sentence", + "isNullSafe": true, + "description": " Represents a sentence containing words", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "words", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "words", + "type": "List", + "description": " Words in this sentence", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "wordCount", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/speed_reader.dart", + "name": "Paragraph", + "isNullSafe": true, + "description": " Represents a paragraph containing sentences", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "sentences", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "sentences", + "type": "List", + "description": " Sentences in this paragraph", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "wordCount", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sentenceCount", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/speed_reader.dart", + "name": "LdSpeedReaderState", + "isNullSafe": true, + "description": " State object for the speed reader", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "isPlaying", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "paragraphs", + "description": "", + "type": "List", + "named": true, + "required": false, + "defaultValue": "const []", + "annotations": [] + }, + { + "name": "speed", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "400", + "annotations": [] + }, + { + "name": "currentParagraphIndex", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "currentSentenceIndex", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "currentWordIndex", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "isPlaying", + "type": "bool", + "description": " Whether reading is active", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "speed", + "type": "int", + "description": " Current reading speed in WPM", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "currentParagraphIndex", + "type": "int", + "description": " Current paragraph index (0-based)", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "currentSentenceIndex", + "type": "int", + "description": " Current sentence index within paragraph (0-based)", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "currentWordIndex", + "type": "int", + "description": " Current word index within sentence (0-based)", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "paragraphs", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "currentWord", + "type": "String?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "paragraphProgress", + "type": "List", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "copyWith", + "returnType": "LdSpeedReaderState", + "signature": [ + { + "name": "paragraphs", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isPlaying", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "currentIndex", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "totalWords", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "speed", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "currentParagraphIndex", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "currentSentenceIndex", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "currentWordIndex", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Creates a copy of this state with the given fields replaced", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/speed_reader.dart", + "name": "LdSpeedReaderController", + "isNullSafe": true, + "description": " Controller for managing speed reader state and logic", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "text", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_stateController", + "type": "StreamController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_state", + "type": "LdSpeedReaderState", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_timer", + "type": "Timer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_disposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "stateStream", + "type": "Stream", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "state", + "type": "LdSpeedReaderState", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_parseText", + "returnType": "void", + "signature": [], + "features": [], + "description": " Parses text into paragraphs, sentences, and words", + "annotations": [] + }, + { + "name": "_parseSentences", + "returnType": "List", + "signature": [ + { + "name": "paragraphText", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Parses a paragraph text into sentences", + "annotations": [] + }, + { + "name": "_setState", + "returnType": "void", + "signature": [ + { + "name": "newState", + "description": "", + "type": "LdSpeedReaderState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Sets the internal state and notifies listeners", + "annotations": [] + }, + { + "name": "_getWordDelay", + "returnType": "int", + "signature": [ + { + "name": "wpm", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Calculates word delay in milliseconds based on WPM", + "annotations": [] + }, + { + "name": "start", + "returnType": "void", + "signature": [], + "features": [], + "description": " Starts reading", + "annotations": [] + }, + { + "name": "pause", + "returnType": "void", + "signature": [], + "features": [], + "description": " Pauses reading", + "annotations": [] + }, + { + "name": "restart", + "returnType": "void", + "signature": [], + "features": [], + "description": " Restarts reading from the beginning", + "annotations": [] + }, + { + "name": "setSpeed", + "returnType": "void", + "signature": [ + { + "name": "wpm", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Sets the reading speed", + "annotations": [] + }, + { + "name": "jumpBackSentence", + "returnType": "void", + "signature": [], + "features": [], + "description": " Jumps back to the start of the current sentence, or to the previous sentence if already at the start", + "annotations": [] + }, + { + "name": "jumpBackParagraph", + "returnType": "void", + "signature": [], + "features": [], + "description": " Jumps back to the start of the current paragraph, or to the previous paragraph if already at the start", + "annotations": [] + }, + { + "name": "_displayNextWord", + "returnType": "void", + "signature": [], + "features": [], + "description": " Displays the next word", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Disposes of the controller", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/speed_reader.dart", + "name": "LdSpeedReader", + "isNullSafe": true, + "description": " A speed reader widget that displays text one word at a time", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "speedOptions", + "description": "", + "type": "List", + "named": true, + "required": false, + "defaultValue": "const [300, 400, 500, 600, 700]", + "annotations": [] + }, + { + "name": "expandText", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdSpeedReaderController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "text", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "controller", + "type": "LdSpeedReaderController?", + "description": " The controller managing the speed reader state", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "speedOptions", + "type": "List", + "description": " Default speed options in WPM", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "expandText", + "type": "bool", + "description": " Whether to expand the text, to full height.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "text", + "type": "String?", + "description": " The text to display", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/speed_reader.dart", + "name": "_LdSpeedReaderState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_controller", + "type": "LdSpeedReaderController", + "description": "", + "features": [ + "late" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdSpeedReader", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/hint.dart", + "name": "_LdHintWidget", + "isNullSafe": true, + "description": " A colored badge with an icon and a text", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdHintType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "type": "CrossAxisAlignment", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('info', defaults: {'type' : 'LdHintType.info'}), Variant('warning', defaults: {'type' : 'LdHintType.warning'}), Variant('success', defaults: {'type' : 'LdHintType.success'}), Variant('error', defaults: {'type' : 'LdHintType.error'}), Variant('canceled', defaults: {'type' : 'LdHintType.canceled'}), Variant('loading', defaults: {'type' : 'LdHintType.loading'}), Variant('pending', defaults: {'type' : 'LdHintType.pending'}), Variant('ongoing', defaults: {'type' : 'LdHintType.ongoing'})])" + ], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/hint.dart", + "name": "LdInfoIcon", + "isNullSafe": true, + "description": " Draws an i in emd shapes", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/hint.dart", + "name": "LdExclamationIcon", + "isNullSafe": true, + "description": " An exclamation icon in emd shapes", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/hint.dart", + "name": "LdCrossIcon", + "isNullSafe": true, + "description": " A cross icon.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/hint.dart", + "name": "LdHint", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "info", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "warning", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "success", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "error", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "canceled", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "loading", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "pending", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "ongoing", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdHintType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "type": "CrossAxisAlignment", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/hint.dart", + "name": "LdHintType", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "info", + "type": "LdHintType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "warning", + "type": "LdHintType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "success", + "type": "LdHintType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "error", + "type": "LdHintType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "canceled", + "type": "LdHintType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "loading", + "type": "LdHintType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "pending", + "type": "LdHintType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "ongoing", + "type": "LdHintType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/breadcrumb.dart", + "name": "LdBreadcrumb", + "isNullSafe": true, + "description": " A breadcrumb widget.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "children", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "fromStrings", + "signature": [ + { + "name": "items", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "children", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/overflow/flexible_child.dart", + "name": "LdFlexibleChild", + "isNullSafe": true, + "description": " A widget that makes its child flexible within an [LdOverflowView].\n\n Similar to [Expanded] but works with [LdOverflowView] instead of [Flex].\n The child will consume the remaining space in the main axis based on its flex value.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "flex", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "debugTypicalAncestorWidgetClass", + "type": "Type", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugTypicalAncestorWidgetDescription", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": " The widget below this widget in the tree.\n\n {@template flutter.widgets.ProxyWidget.child}\n This widget can only have one child. To lay out multiple children, let this\n widget's child be a widget such as [Row], [Column], or [Stack], which have a\n `children` property, and then provide the children to that widget.\n {@endtemplate}", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "flex", + "type": "int", + "description": " The flex value to use when distributing remaining space.\n\n The remaining space will be distributed proportionally based on the flex values\n of all FlexibleChild widgets. Defaults to 1.", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "debugIsValidRenderObject", + "returnType": "bool", + "signature": [ + { + "name": "renderObject", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Checks if this widget can apply its parent data to the provided\n `renderObject`.\n\n The [RenderObject.parentData] of the provided `renderObject` is\n typically set up by an ancestor [RenderObjectWidget] of the type returned\n by [debugTypicalAncestorWidgetClass].\n\n This is called just before [applyParentData] is invoked with the same\n [RenderObject] provided to that method.", + "annotations": [] + }, + { + "name": "_debugDescribeIncorrectParentDataType", + "returnType": "Iterable", + "signature": [ + { + "name": "parentData", + "description": "", + "type": "ParentData?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "parentDataCreator", + "description": "", + "type": "RenderObjectWidget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "ownershipChain", + "description": "", + "type": "DiagnosticsNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "applyParentData", + "returnType": "void", + "signature": [ + { + "name": "renderObject", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugCanApplyOutOfTurn", + "returnType": "bool", + "signature": [], + "features": [], + "description": " Whether the [ParentDataElement.applyWidgetOutOfTurn] method is allowed\n with this widget.\n\n This should only return true if this widget represents a [ParentData]\n configuration that will have no impact on the layout or paint phase.\n\n See also:\n\n * [ParentDataElement.applyWidgetOutOfTurn], which verifies this in debug\n mode.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "ParentDataWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/overflow/overflow_rendering.dart", + "name": "LdOverflowViewParentData", + "isNullSafe": true, + "description": " Parent data for use with [RenderOverflowView].", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "offset", + "type": "Offset", + "description": " The offset at which to paint the child in the parent's coordinate system.", + "features": [], + "annotations": [] + }, + { + "name": "previousSibling", + "type": "ChildType?", + "description": " The previous sibling in the parent's child list.", + "features": [], + "annotations": [] + }, + { + "name": "nextSibling", + "type": "ChildType?", + "description": " The next sibling in the parent's child list.", + "features": [], + "annotations": [] + }, + { + "name": "offstage", + "type": "bool?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "consumeRemainder", + "type": "int?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "detach", + "returnType": "void", + "signature": [], + "features": [], + "description": " Clear the sibling pointers.", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "ContainerBoxParentData", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/overflow/overflow_rendering.dart", + "name": "LdRenderOverflowView", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "children", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "direction", + "description": "", + "type": "Axis", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "spacing", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mainAxisAlignment", + "description": "", + "type": "MainAxisAlignment", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_layoutCacheStorage", + "type": "_LayoutCacheStorage", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_computingThisDryLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_computingThisDryBaseline", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_size", + "type": "Size?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugActivePointers", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasSize", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "size", + "type": "Size", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "semanticBounds", + "type": "Rect", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "constraints", + "type": "Constraints", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "paintBounds", + "type": "Rect", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDisposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "parentData", + "type": "ParentData?", + "description": " Data for use by the parent render object.\n\n The parent data is used by the render object that lays out this object\n (typically this object's parent in the render tree) to store information\n relevant to itself and to any other nodes who happen to know exactly what\n the data means. The parent data is opaque to the child.\n\n * The parent data field must not be directly set, except by calling\n [setupParentData] on the parent node.\n * The parent data can be set before the child is added to the parent, by\n calling [setupParentData] on the future parent node.\n * The conventions for using the parent data depend on the layout protocol\n used between the parent and child. For example, in box layout, the\n parent data is completely opaque but in sector layout the child is\n permitted to read some fields of the parent data.", + "features": [], + "annotations": [] + }, + { + "name": "_depth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_parent", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugCreator", + "type": "Object?", + "description": " The object responsible for creating this render object.\n\n Used in debug messages.\n\n See also:\n\n * [DebugCreator], which the [widgets] library uses as values for this field.", + "features": [], + "annotations": [] + }, + { + "name": "_debugDoingThisResize", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDoingThisLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCanParentUseSize", + "type": "bool?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugMutationsLocked", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_owner", + "type": "PipelineOwner?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_needsLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isRelayoutBoundary", + "type": "bool?", + "description": " Whether this [RenderObject] is a known relayout boundary.\n\n A relayout boundary is a [RenderObject] whose parent does not rely on the\n child [RenderObject]'s size in its own layout algorithm. In other words,\n if a [RenderObject]'s [performLayout] implementation does not ask the child\n for its size at all, **the child** is a relayout boundary.\n\n The type of \"size\" is typically defined by the coordinate system a\n [RenderObject] subclass uses. For instance, [RenderSliver]s produce\n [SliverGeometry] and [RenderBox]es produce [Size]. A parent [RenderObject]\n may not read the child's size but still depend on the child's layout (using\n a [RenderBox] child's baseline location, for example), this flag does not\n reflect such dependencies and the [RenderObject] subclass must handle those\n cases in its own implementation. See [RenderBox.markNeedsLayout] for an\n example.\n\n Relayout boundaries enable an important layout optimization: the parent not\n depending on the size of a child means the child changing size does not\n affect the layout of the parent. When a relayout boundary is marked as\n needing layout, its parent does not have to be marked as dirty, hence the\n name. For details, see [markNeedsLayout].\n\n This flag is typically set in [RenderObject.layout], and consulted by\n [markNeedsLayout] in deciding whether to recursively mark the parent as\n also needing layout.\n\n The flag is initially set to `null` when [layout] has yet been called, and\n reset to `null` when the parent drops this child via [dropChild].", + "features": [], + "annotations": [] + }, + { + "name": "_doingThisLayoutWithCallback", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_constraints", + "type": "Constraints?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDoingThisPaint", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_wasRepaintBoundary", + "type": "bool", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_layerHandle", + "type": "LayerHandle", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_needsCompositingBitsUpdate", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_needsCompositing", + "type": "bool", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_needsPaint", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_needsCompositedLayerUpdate", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_semantics", + "type": "_RenderObjectSemantics", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "debugDisposed", + "type": "bool?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "depth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "parent", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "semanticsParent", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugDoingThisResize", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugDoingThisLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugCanParentUseSize", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCanPerformMutations", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugLayoutParent", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "owner", + "type": "PipelineOwner?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "attached", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugNeedsLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugDoingThisLayoutWithCallback", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sizedByParent", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugDoingThisPaint", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isRepaintBoundary", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "alwaysNeedsCompositing", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "layer", + "type": "ContainerLayer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugLayer", + "type": "ContainerLayer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "needsCompositing", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugNeedsPaint", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugNeedsCompositedLayerUpdate", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugNeedsSemanticsUpdate", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugSemantics", + "type": "SemanticsNode?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_childCount", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_firstChild", + "type": "ChildType?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_lastChild", + "type": "ChildType?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "childCount", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "firstChild", + "type": "ChildType?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "lastChild", + "type": "ChildType?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_mainAxisAlignment", + "type": "MainAxisAlignment", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_crossAxisAlignment", + "type": "CrossAxisAlignment", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_direction", + "type": "Axis", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_spacing", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isHorizontal", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_hasOverflow", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_cachedIndicatorSizes", + "type": "Map?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_lastIndicatorOverflowCount", + "type": "int?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_lastIndicatorConstraints", + "type": "BoxConstraints?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "type": "CrossAxisAlignment", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "direction", + "type": "Axis", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mainAxisAlignment", + "type": "MainAxisAlignment", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "maxCrossExtent", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "maxMainExtent", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "spacing", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_availableExtent", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_children", + "type": "List", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "setupParentData", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_computeIntrinsics", + "returnType": "Output", + "signature": [ + { + "name": "type", + "description": "", + "type": "_CachedLayoutCalculation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "input", + "description": "", + "type": "Input", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "computer", + "description": "", + "type": "Output Function(Input)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_computeWithTimeline", + "returnType": "Output", + "signature": [ + { + "name": "type", + "description": "", + "type": "_CachedLayoutCalculation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "input", + "description": "", + "type": "Input", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "computer", + "description": "", + "type": "Output Function(Input)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getMinIntrinsicWidth", + "returnType": "double", + "signature": [ + { + "name": "height", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the minimum width that this box could be without failing to\n correctly paint its contents within itself, without clipping.\n\n The height argument may give a specific height to assume. The given height\n can be infinite, meaning that the intrinsic width in an unconstrained\n environment is being requested. The given height should never be negative\n or null.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement [computeMinIntrinsicWidth].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "computeMinIntrinsicWidth", + "returnType": "double", + "signature": [ + { + "name": "height", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Computes the value returned by [getMinIntrinsicWidth]. Do not call this\n function directly, instead, call [getMinIntrinsicWidth].\n\n Override in subclasses that implement [performLayout]. This method should\n return the minimum width that this box could be without failing to\n correctly paint its contents within itself, without clipping.\n\n If the layout algorithm is independent of the context (e.g. it always\n tries to be a particular size), or if the layout algorithm is\n width-in-height-out, or if the layout algorithm uses both the incoming\n width and height constraints (e.g. it always sizes itself to\n [BoxConstraints.biggest]), then the `height` argument should be ignored.\n\n If the layout algorithm is strictly height-in-width-out, or is\n height-in-width-out when the width is unconstrained, then the height\n argument is the height to use.\n\n The `height` argument will never be negative or null. It may be infinite.\n\n If this algorithm depends on the intrinsic dimensions of a child, the\n intrinsic dimensions of that child should be obtained using the functions\n whose names start with `get`, not `compute`.\n\n This function should never return a negative or infinite value.\n\n Be sure to set [debugCheckIntrinsicSizes] to true in your unit tests if\n you do override this method, which will add additional checks to help\n validate your implementation.\n\n ## Examples\n\n ### Text\n\n English text is the canonical example of a width-in-height-out algorithm.\n The `height` argument is therefore ignored.\n\n Consider the string \"Hello World\". The _maximum_ intrinsic width (as\n returned from [computeMaxIntrinsicWidth]) would be the width of the string\n with no line breaks.\n\n The minimum intrinsic width would be the width of the widest word, \"Hello\"\n or \"World\". If the text is rendered in an even narrower width, however, it\n might still not overflow. For example, maybe the rendering would put a\n line-break half-way through the words, as in \"Hel⁞lo⁞Wor⁞ld\". However,\n this wouldn't be a _correct_ rendering, and [computeMinIntrinsicWidth] is\n defined as returning the minimum width that the box could be without\n failing to _correctly_ paint the contents within itself.\n\n The minimum intrinsic _height_ for a given width _smaller_ than the\n minimum intrinsic width could therefore be greater than the minimum\n intrinsic height for the minimum intrinsic width.\n\n ### Viewports (e.g. scrolling lists)\n\n Some render boxes are intended to clip their children. For example, the\n render box for a scrolling list might always size itself to its parents'\n size (or rather, to the maximum incoming constraints), regardless of the\n children's sizes, and then clip the children and position them based on\n the current scroll offset.\n\n The intrinsic dimensions in these cases still depend on the children, even\n though the layout algorithm sizes the box in a way independent of the\n children. It is the size that is needed to paint the box's contents (in\n this case, the children) _without clipping_ that matters.\n\n ### When the intrinsic dimensions cannot be known\n\n There are cases where render objects do not have an efficient way to\n compute their intrinsic dimensions. For example, it may be prohibitively\n expensive to reify and measure every child of a lazy viewport (viewports\n generally only instantiate the actually visible children), or the\n dimensions may be computed by a callback about which the render object\n cannot reason.\n\n In such cases, it may be impossible (or at least impractical) to actually\n return a valid answer. In such cases, the intrinsic functions should throw\n when [RenderObject.debugCheckingIntrinsics] is false and asserts are\n enabled, and return 0.0 otherwise.\n\n See the implementations of [LayoutBuilder] or [RenderViewportBase] for\n examples (in particular,\n [RenderViewportBase.debugThrowIfNotCheckingIntrinsics]).\n\n ### Aspect-ratio-driven boxes\n\n Some boxes always return a fixed size based on the constraints. For these\n boxes, the intrinsic functions should return the appropriate size when the\n incoming `height` or `width` argument is finite, treating that as a tight\n constraint in the respective direction and treating the other direction's\n constraints as unbounded. This is because the definitions of\n [computeMinIntrinsicWidth] and [computeMinIntrinsicHeight] are in terms of\n what the dimensions _could be_, and such boxes can only be one size in\n such cases.\n\n When the incoming argument is not finite, then they should return the\n actual intrinsic dimensions based on the contents, as any other box would.\n\n See also:\n\n * [computeMaxIntrinsicWidth], which computes the smallest width beyond\n which increasing the width never decreases the preferred height.", + "annotations": [ + "@protected" + ] + }, + { + "name": "getMaxIntrinsicWidth", + "returnType": "double", + "signature": [ + { + "name": "height", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the smallest width beyond which increasing the width never\n decreases the preferred height. The preferred height is the value that\n would be returned by [getMinIntrinsicHeight] for that width.\n\n The height argument may give a specific height to assume. The given height\n can be infinite, meaning that the intrinsic width in an unconstrained\n environment is being requested. The given height should never be negative\n or null.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement\n [computeMaxIntrinsicWidth].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "computeMaxIntrinsicWidth", + "returnType": "double", + "signature": [ + { + "name": "height", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Computes the value returned by [getMaxIntrinsicWidth]. Do not call this\n function directly, instead, call [getMaxIntrinsicWidth].\n\n Override in subclasses that implement [performLayout]. This should return\n the smallest width beyond which increasing the width never decreases the\n preferred height. The preferred height is the value that would be returned\n by [computeMinIntrinsicHeight] for that width.\n\n If the layout algorithm is strictly height-in-width-out, or is\n height-in-width-out when the width is unconstrained, then this should\n return the same value as [computeMinIntrinsicWidth] for the same height.\n\n Otherwise, the height argument should be ignored, and the returned value\n should be equal to or bigger than the value returned by\n [computeMinIntrinsicWidth].\n\n The `height` argument will never be negative or null. It may be infinite.\n\n The value returned by this method might not match the size that the object\n would actually take. For example, a [RenderBox] subclass that always\n exactly sizes itself using [BoxConstraints.biggest] might well size itself\n bigger than its max intrinsic size.\n\n If this algorithm depends on the intrinsic dimensions of a child, the\n intrinsic dimensions of that child should be obtained using the functions\n whose names start with `get`, not `compute`.\n\n This function should never return a negative or infinite value.\n\n Be sure to set [debugCheckIntrinsicSizes] to true in your unit tests if\n you do override this method, which will add additional checks to help\n validate your implementation.\n\n See also:\n\n * [computeMinIntrinsicWidth], which has usage examples.", + "annotations": [ + "@visibleForOverriding", + "@protected" + ] + }, + { + "name": "getMinIntrinsicHeight", + "returnType": "double", + "signature": [ + { + "name": "width", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the minimum height that this box could be without failing to\n correctly paint its contents within itself, without clipping.\n\n The width argument may give a specific width to assume. The given width\n can be infinite, meaning that the intrinsic height in an unconstrained\n environment is being requested. The given width should never be negative\n or null.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement\n [computeMinIntrinsicHeight].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "computeMinIntrinsicHeight", + "returnType": "double", + "signature": [ + { + "name": "width", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Computes the value returned by [getMinIntrinsicHeight]. Do not call this\n function directly, instead, call [getMinIntrinsicHeight].\n\n Override in subclasses that implement [performLayout]. Should return the\n minimum height that this box could be without failing to correctly paint\n its contents within itself, without clipping.\n\n If the layout algorithm is independent of the context (e.g. it always\n tries to be a particular size), or if the layout algorithm is\n height-in-width-out, or if the layout algorithm uses both the incoming\n height and width constraints (e.g. it always sizes itself to\n [BoxConstraints.biggest]), then the `width` argument should be ignored.\n\n If the layout algorithm is strictly width-in-height-out, or is\n width-in-height-out when the height is unconstrained, then the width\n argument is the width to use.\n\n The `width` argument will never be negative or null. It may be infinite.\n\n If this algorithm depends on the intrinsic dimensions of a child, the\n intrinsic dimensions of that child should be obtained using the functions\n whose names start with `get`, not `compute`.\n\n This function should never return a negative or infinite value.\n\n Be sure to set [debugCheckIntrinsicSizes] to true in your unit tests if\n you do override this method, which will add additional checks to help\n validate your implementation.\n\n See also:\n\n * [computeMinIntrinsicWidth], which has usage examples.\n * [computeMaxIntrinsicHeight], which computes the smallest height beyond\n which increasing the height never decreases the preferred width.", + "annotations": [ + "@visibleForOverriding", + "@protected" + ] + }, + { + "name": "getMaxIntrinsicHeight", + "returnType": "double", + "signature": [ + { + "name": "width", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the smallest height beyond which increasing the height never\n decreases the preferred width. The preferred width is the value that\n would be returned by [getMinIntrinsicWidth] for that height.\n\n The width argument may give a specific width to assume. The given width\n can be infinite, meaning that the intrinsic height in an unconstrained\n environment is being requested. The given width should never be negative\n or null.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement\n [computeMaxIntrinsicHeight].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "computeMaxIntrinsicHeight", + "returnType": "double", + "signature": [ + { + "name": "width", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Computes the value returned by [getMaxIntrinsicHeight]. Do not call this\n function directly, instead, call [getMaxIntrinsicHeight].\n\n Override in subclasses that implement [performLayout]. Should return the\n smallest height beyond which increasing the height never decreases the\n preferred width. The preferred width is the value that would be returned\n by [computeMinIntrinsicWidth] for that height.\n\n If the layout algorithm is strictly width-in-height-out, or is\n width-in-height-out when the height is unconstrained, then this should\n return the same value as [computeMinIntrinsicHeight] for the same width.\n\n Otherwise, the width argument should be ignored, and the returned value\n should be equal to or bigger than the value returned by\n [computeMinIntrinsicHeight].\n\n The `width` argument will never be negative or null. It may be infinite.\n\n The value returned by this method might not match the size that the object\n would actually take. For example, a [RenderBox] subclass that always\n exactly sizes itself using [BoxConstraints.biggest] might well size itself\n bigger than its max intrinsic size.\n\n If this algorithm depends on the intrinsic dimensions of a child, the\n intrinsic dimensions of that child should be obtained using the functions\n whose names start with `get`, not `compute`.\n\n This function should never return a negative or infinite value.\n\n Be sure to set [debugCheckIntrinsicSizes] to true in your unit tests if\n you do override this method, which will add additional checks to help\n validate your implementation.\n\n See also:\n\n * [computeMinIntrinsicWidth], which has usage examples.", + "annotations": [ + "@visibleForOverriding", + "@protected" + ] + }, + { + "name": "getDryLayout", + "returnType": "Size", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the [Size] that this [RenderBox] would like to be given the\n provided [BoxConstraints].\n\n The size returned by this method is guaranteed to be the same size that\n this [RenderBox] computes for itself during layout given the same\n constraints.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n This layout is called \"dry\" layout as opposed to the regular \"wet\" layout\n run performed by [performLayout] because it computes the desired size for\n the given constraints without changing any internal state.\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement [computeDryLayout].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "_computeDryLayout", + "returnType": "Size", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "computeDryLayout", + "returnType": "Size", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Computes the value returned by [getDryLayout]. Do not call this\n function directly, instead, call [getDryLayout].\n\n Override in subclasses that implement [performLayout] or [performResize]\n or when setting [sizedByParent] to true without overriding\n [performResize]. This method should return the [Size] that this\n [RenderBox] would like to be given the provided [BoxConstraints].\n\n The size returned by this method must match the [size] that the\n [RenderBox] will compute for itself in [performLayout] (or\n [performResize], if [sizedByParent] is true).\n\n If this algorithm depends on the size of a child, the size of that child\n should be obtained using its [getDryLayout] method.\n\n This layout is called \"dry\" layout as opposed to the regular \"wet\" layout\n run performed by [performLayout] because it computes the desired size for\n the given constraints without changing any internal state.\n\n ### When the size cannot be known\n\n There are cases where render objects do not have an efficient way to\n compute their size. For example, the size may computed by a callback about\n which the render object cannot reason.\n\n In such cases, it may be impossible (or at least impractical) to actually\n return a valid answer. In such cases, the function should call\n [debugCannotComputeDryLayout] from within an assert and return a dummy\n value of `const Size(0, 0)`.", + "annotations": [ + "@visibleForOverriding", + "@protected" + ] + }, + { + "name": "getDryBaseline", + "returnType": "double?", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the distance from the top of the box to the first baseline of the\n box's contents for the given `constraints`, or `null` if this [RenderBox]\n does not have any baselines.\n\n This method calls [computeDryBaseline] under the hood and caches the result.\n [RenderBox] subclasses typically don't overridden [getDryBaseline]. Instead,\n consider overriding [computeDryBaseline] such that it returns a baseline\n location that is consistent with [getDistanceToActualBaseline]. See the\n documentation for the [computeDryBaseline] method for more details.\n\n This method is usually called by the [computeDryBaseline] or the\n [computeDryLayout] implementation of a parent [RenderBox] to get the\n baseline location of a [RenderBox] child. Unlike [getDistanceToBaseline],\n this method takes a [BoxConstraints] as an argument and computes the\n baseline location as if the [RenderBox] was laid out by the parent using\n that [BoxConstraints].\n\n The \"dry\" in the method name means this method, like [getDryLayout], has\n no observable side effects when called, as opposed to \"wet\" layout methods\n such as [performLayout] (which changes this [RenderBox]'s [size], and the\n offsets of its children if any). Since this method does not depend on the\n current layout, unlike [getDistanceToBaseline], it's ok to call this method\n when this [RenderBox]'s layout is outdated.\n\n Similar to the intrinsic width/height and [getDryLayout], calling this\n function in [performLayout] is expensive, as it can result in O(N^2) layout\n performance, where N is the number of render objects in the render subtree.\n Typically this method should be only called by the parent [RenderBox]'s\n [computeDryBaseline] or [computeDryLayout] implementation.", + "annotations": [] + }, + { + "name": "_computeDryBaseline", + "returnType": "BaselineOffset", + "signature": [ + { + "name": "pair", + "description": "", + "type": "(BoxConstraints, TextBaseline)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "computeDryBaseline", + "returnType": "double?", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Computes the value returned by [getDryBaseline].\n\n This method is for overriding only and shouldn't be called directly. To\n get this [RenderBox]'s speculative baseline location for the given\n `constraints`, call [getDryBaseline] instead.\n\n The \"dry\" in the method name means the implementation must not produce\n observable side effects when called. For example, it must not change the\n [size] of the [RenderBox], or its children's paint offsets, otherwise that\n would results in UI changes when [paint] is called, or hit-testing behavior\n changes when [hitTest] is called. Moreover, accessing the current layout\n of this [RenderBox] or child [RenderBox]es (including accessing [size], or\n `child.size`) usually indicates a bug in the implementation, as the current\n layout is typically calculated using a set of [BoxConstraints] that's\n different from the `constraints` given as the first parameter. To get the\n size of this [RenderBox] or a child [RenderBox] in this method's\n implementation, use the [getDryLayout] method instead.\n\n The implementation must return a value that represents the distance from\n the top of the box to the first baseline of the box's contents, for the\n given `constraints`, or `null` if the [RenderBox] has no baselines. It's\n the same exact value [RenderBox.computeDistanceToActualBaseline] would\n return, when this [RenderBox] was laid out at `constraints` in the same\n exact state.\n\n Not all [RenderBox]es support dry baseline computation. For example, to\n compute the dry baseline of a [LayoutBuilder], its `builder` may have to\n be called with different constraints, which may have side effects such as\n updating the widget tree, violating the \"dry\" contract. In such cases the\n [RenderBox] must call [debugCannotComputeDryLayout] in an assert, and\n return a dummy baseline offset value (such as `null`).", + "annotations": [ + "@visibleForOverriding", + "@protected" + ] + }, + { + "name": "debugCannotComputeDryLayout", + "returnType": "bool", + "signature": [ + { + "name": "reason", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "error", + "description": "", + "type": "FlutterError?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called from [computeDryLayout] or [computeDryBaseline] within an assert if\n the given [RenderBox] subclass does not support calculating a dry layout.\n\n When asserts are enabled and [debugCheckingIntrinsics] is not true, this\n method will either throw the provided [FlutterError] or it will create and\n throw a [FlutterError] with the provided `reason`. Otherwise, it will\n return true.\n\n One of the arguments has to be provided.\n\n See also:\n\n * [computeDryLayout], which lists some reasons why it may not be feasible\n to compute the dry layout.", + "annotations": [] + }, + { + "name": "debugAdoptSize", + "returnType": "Size", + "signature": [ + { + "name": "value", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Claims ownership of the given [Size].\n\n In debug mode, the [RenderBox] class verifies that [Size] objects obtained\n from other [RenderBox] objects are only used according to the semantics of\n the [RenderBox] protocol, namely that a [Size] from a [RenderBox] can only\n be used by its parent, and then only if `parentUsesSize` was set.\n\n Sometimes, a [Size] that can validly be used ends up no longer being valid\n over time. The common example is a [Size] taken from a child that is later\n removed from the parent. In such cases, this method can be called to first\n check whether the size can legitimately be used, and if so, to then create\n a new [Size] that can be used going forward, regardless of what happens to\n the original owner.", + "annotations": [] + }, + { + "name": "debugResetSize", + "returnType": "void", + "signature": [], + "features": [], + "description": " If a subclass has a \"size\" (the state controlled by `parentUsesSize`,\n whatever it is in the subclass, e.g. the actual `size` property of\n [RenderBox]), and the subclass verifies that in debug mode this \"size\"\n property isn't used when [debugCanParentUseSize] isn't set, then that\n subclass should override [debugResetSize] to reapply the current values of\n [debugCanParentUseSize] to that state.", + "annotations": [ + "@protected" + ] + }, + { + "name": "getDistanceToBaseline", + "returnType": "double?", + "signature": [ + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onlyReal", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Returns the distance from the y-coordinate of the position of the box to\n the y-coordinate of the first given baseline in the box's contents.\n\n Used by certain layout models to align adjacent boxes on a common\n baseline, regardless of padding, font size differences, etc. If there is\n no baseline, this function returns the distance from the y-coordinate of\n the position of the box to the y-coordinate of the bottom of the box\n (i.e., the height of the box) unless the caller passes true\n for `onlyReal`, in which case the function returns null.\n\n Only call this function after calling [layout] on this box. You\n are only allowed to call this from the parent of this box during\n that parent's [performLayout] or [paint] functions.\n\n When implementing a [RenderBox] subclass, to override the baseline\n computation, override [computeDistanceToActualBaseline].\n\n See also:\n\n * [getDryBaseline], which returns the baseline location of this\n [RenderBox] at a certain [BoxConstraints].", + "annotations": [] + }, + { + "name": "getDistanceToActualBaseline", + "returnType": "double?", + "signature": [ + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Calls [computeDistanceToActualBaseline] and caches the result.\n\n This function must only be called from [getDistanceToBaseline] and\n [computeDistanceToActualBaseline]. Do not call this function directly from\n outside those two methods.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "computeDistanceToActualBaseline", + "returnType": "double?", + "signature": [ + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the distance from the y-coordinate of the position of the box to\n the y-coordinate of the first given baseline in the box's contents, if\n any, or null otherwise.\n\n Do not call this function directly. If you need to know the baseline of a\n child from an invocation of [performLayout] or [paint], call\n [getDistanceToBaseline].\n\n Subclasses should override this method to supply the distances to their\n baselines. When implementing this method, there are generally three\n strategies:\n\n * For classes that use the [ContainerRenderObjectMixin] child model,\n consider mixing in the [RenderBoxContainerDefaultsMixin] class and\n using\n [RenderBoxContainerDefaultsMixin.defaultComputeDistanceToFirstActualBaseline].\n\n * For classes that define a particular baseline themselves, return that\n value directly.\n\n * For classes that have a child to which they wish to defer the\n computation, call [getDistanceToActualBaseline] on the child (not\n [computeDistanceToActualBaseline], the internal implementation, and not\n [getDistanceToBaseline], the public entry point for this API).", + "annotations": [ + "@visibleForOverriding", + "@protected" + ] + }, + { + "name": "debugAssertDoesMeetConstraints", + "returnType": "void", + "signature": [], + "features": [ + "abstract" + ], + "description": " Verify that the object's constraints are being met. Override this function\n in a subclass to verify that your state matches the constraints object.\n This function is only called when asserts are enabled (i.e. in debug mode)\n and only when needsLayout is false. If the constraints are not met, it\n should assert or throw an exception.", + "annotations": [ + "@protected" + ] + }, + { + "name": "_debugVerifyDryBaselines", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "markNeedsLayout", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object's layout information as dirty, and either register\n this object with its [PipelineOwner], or defer to the parent, depending on\n whether this object is a relayout boundary or not respectively.\n\n ## Background\n\n Rather than eagerly updating layout information in response to writes into\n a render object, we instead mark the layout information as dirty, which\n schedules a visual update. As part of the visual update, the rendering\n pipeline updates the render object's layout information.\n\n This mechanism batches the layout work so that multiple sequential writes\n are coalesced, removing redundant computation.\n\n If a render object's parent indicates that it uses the size of one of its\n render object children when computing its layout information, this\n function, when called for the child, will also mark the parent as needing\n layout. In that case, since both the parent and the child need to have\n their layout recomputed, the pipeline owner is only notified about the\n parent; when the parent is laid out, it will call the child's [layout]\n method and thus the child will be laid out as well.\n\n Once [markNeedsLayout] has been called on a render object,\n [debugNeedsLayout] returns true for that render object until just after\n the pipeline owner has called [layout] on the render object.\n\n ## Special cases\n\n Some subclasses of [RenderObject], notably [RenderBox], have other\n situations in which the parent needs to be notified if the child is\n dirtied (e.g., if the child's intrinsic dimensions or baseline changes).\n Such subclasses override markNeedsLayout and either call\n `super.markNeedsLayout()`, in the normal case, or call\n [markParentNeedsLayout], in the case where the parent needs to be laid out\n as well as the child.\n\n If [sizedByParent] has changed, calls\n [markNeedsLayoutForSizedByParentChange] instead of [markNeedsLayout].", + "annotations": [] + }, + { + "name": "performResize", + "returnType": "void", + "signature": [], + "features": [ + "abstract" + ], + "description": " {@template flutter.rendering.RenderObject.performResize}\n Updates the render objects size using only the constraints.\n\n Do not call this function directly: call [layout] instead. This function\n is called by [layout] when there is actually work to be done by this\n render object during layout. The layout constraints provided by your\n parent are available via the [constraints] getter.\n\n This function is called only if [sizedByParent] is true.\n {@endtemplate}\n\n Subclasses that set [sizedByParent] to true should override this method to\n compute their size. Subclasses of [RenderBox] should consider overriding\n [RenderBox.computeDryLayout] instead.", + "annotations": [ + "@protected" + ] + }, + { + "name": "performLayout", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "hitTest", + "returnType": "bool", + "signature": [ + { + "name": "result", + "description": "", + "type": "BoxHitTestResult", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "Offset", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Determines the set of render objects located at the given position.\n\n Returns true, and adds any render objects that contain the point to the\n given hit test result, if this render object or one of its descendants\n absorbs the hit (preventing objects below this one from being hit).\n Returns false if the hit can continue to other objects below this one.\n\n The caller is responsible for transforming [position] from global\n coordinates to its location relative to the origin of this [RenderBox].\n This [RenderBox] is responsible for checking whether the given position is\n within its bounds.\n\n If transforming is necessary, [BoxHitTestResult.addWithPaintTransform],\n [BoxHitTestResult.addWithPaintOffset], or\n [BoxHitTestResult.addWithRawTransform] need to be invoked by the caller\n to record the required transform operations in the [HitTestResult]. These\n methods will also help with applying the transform to `position`.\n\n Hit testing requires layout to be up-to-date but does not require painting\n to be up-to-date. That means a render object can rely upon [performLayout]\n having been called in [hitTest] but cannot rely upon [paint] having been\n called. For example, a render object might be a child of a [RenderOpacity]\n object, which calls [hitTest] on its children when its opacity is zero\n even though it does not [paint] its children.", + "annotations": [] + }, + { + "name": "hitTestSelf", + "returnType": "bool", + "signature": [ + { + "name": "position", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Override this method if this render object can be hit even if its\n children were not hit.\n\n Returns true if the specified `position` should be considered a hit\n on this render object.\n\n The caller is responsible for transforming [position] from global\n coordinates to its location relative to the origin of this [RenderBox].\n This [RenderBox] is responsible for checking whether the given position is\n within its bounds.\n\n Used by [hitTest]. If you override [hitTest] and do not call this\n function, then you don't need to implement this function.", + "annotations": [ + "@protected" + ] + }, + { + "name": "hitTestChildren", + "returnType": "bool", + "signature": [ + { + "name": "result", + "description": "", + "type": "BoxHitTestResult", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "Offset", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "applyPaintTransform", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "transform", + "description": "", + "type": "Matrix4", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Applies the transform that would be applied when painting the given child\n to the given matrix.\n\n Used by coordinate conversion functions ([getTransformTo], for example) to\n translate coordinates local to one render object into coordinates local to\n another render object.\n\n Some RenderObjects will provide a zeroed out matrix in this method,\n indicating that the child should not paint anything or respond to hit\n tests currently. A parent may supply a non-zero matrix even though it\n does not paint its child currently, for example if the parent is a\n [RenderOffstage] with `offstage` set to true. In both of these cases,\n the parent must return `false` from [paintsChild].", + "annotations": [] + }, + { + "name": "globalToLocal", + "returnType": "Offset", + "signature": [ + { + "name": "point", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "ancestor", + "description": "", + "type": "RenderObject?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Convert the given point from the global coordinate system in logical pixels\n to the local coordinate system for this box.\n\n This method will un-project the point from the screen onto the widget,\n which makes it different from [MatrixUtils.transformPoint].\n\n If the transform from global coordinates to local coordinates is\n degenerate, this function returns [Offset.zero].\n\n If `ancestor` is non-null, this function converts the given point from the\n coordinate system of `ancestor` (which must be an ancestor of this render\n object) instead of from the global coordinate system.\n\n This method is implemented in terms of [getTransformTo].", + "annotations": [] + }, + { + "name": "localToGlobal", + "returnType": "Offset", + "signature": [ + { + "name": "point", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "ancestor", + "description": "", + "type": "RenderObject?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Convert the given point from the local coordinate system for this box to\n the global coordinate system in logical pixels.\n\n If `ancestor` is non-null, this function converts the given point to the\n coordinate system of `ancestor` (which must be an ancestor of this render\n object) instead of to the global coordinate system.\n\n This method is implemented in terms of [getTransformTo]. If the transform\n matrix puts the given `point` on the line at infinity (for instance, when\n the transform matrix is the zero matrix), this method returns (NaN, NaN).", + "annotations": [] + }, + { + "name": "handleEvent", + "returnType": "void", + "signature": [ + { + "name": "event", + "description": "", + "type": "PointerEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "entry", + "description": "", + "type": "HitTestEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Override this method to receive events.", + "annotations": [] + }, + { + "name": "debugHandleEvent", + "returnType": "bool", + "signature": [ + { + "name": "event", + "description": "", + "type": "PointerEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "entry", + "description": "", + "type": "HitTestEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Implements the [debugPaintPointersEnabled] debugging feature.\n\n [RenderBox] subclasses that implement [handleEvent] should call\n [debugHandleEvent] from their [handleEvent] method, as follows:\n\n ```dart\n class RenderFoo extends RenderBox {\n // ...\n\n @override\n void handleEvent(PointerEvent event, HitTestEntry entry) {\n assert(debugHandleEvent(event, entry));\n // ... handle the event ...\n }\n\n // ...\n }\n ```\n\n If you call this for a [PointerDownEvent], make sure you also call it for\n the corresponding [PointerUpEvent] or [PointerCancelEvent].", + "annotations": [] + }, + { + "name": "debugPaint", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Override this method to paint debugging information.", + "annotations": [] + }, + { + "name": "debugPaintSize", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " In debug mode, paints a border around this render box.\n\n Called for every [RenderBox] when [debugPaintSizeEnabled] is true.", + "annotations": [ + "@protected", + "@visibleForTesting" + ] + }, + { + "name": "debugPaintBaselines", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " In debug mode, paints a line for each baseline.\n\n Called for every [RenderBox] when [debugPaintBaselinesEnabled] is true.", + "annotations": [ + "@protected" + ] + }, + { + "name": "debugPaintPointers", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " In debug mode, paints a rectangle if this render box has counted more\n pointer downs than pointer up events.\n\n Called for every [RenderBox] when [debugPaintPointersEnabled] is true.\n\n By default, events are not counted. For details on how to ensure that\n events are counted for your class, see [debugHandleEvent].", + "annotations": [ + "@protected" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " Cause the entire subtree rooted at the given [RenderObject] to be marked\n dirty for layout, paint, etc, so that the effects of a hot reload can be\n seen, or so that the effect of changing a global debug flag (such as\n [debugPaintSizeEnabled]) can be applied.\n\n This is called by the [RendererBinding] in response to the\n `ext.flutter.reassemble` hook, which is used by development tools when the\n application code has changed, to cause the widget tree to pick up any\n changed implementations.\n\n This is expensive and should not be called except during development.\n\n See also:\n\n * [BindingBase.reassembleApplication]", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Release any resources held by this render object.\n\n The object that creates a RenderObject is in charge of disposing it.\n If this render object has created any children directly, it must dispose\n of those children in this method as well. It must not dispose of any\n children that were created by some other object, such as\n a [RenderObjectElement]. Those children will be disposed when that\n element unmounts, which may be delayed if the element is moved to another\n part of the tree.\n\n Implementations of this method must end with a call to the inherited\n method, as in `super.dispose()`.\n\n The object is no longer usable after calling dispose.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "redepthChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Adjust the [depth] of the given [child] to be greater than this node's own\n [depth].\n\n Only call this method from overrides of [redepthChildren].", + "annotations": [ + "@protected" + ] + }, + { + "name": "redepthChildren", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "adoptChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called by subclasses when they decide a render object is a child.\n\n Only for use by subclasses when changing their child lists. Calling this\n in other cases will lead to an inconsistent tree and probably cause crashes.", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "dropChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called by subclasses when they decide a render object is no longer a child.\n\n Only for use by subclasses when changing their child lists. Calling this\n in other cases will lead to an inconsistent tree and probably cause crashes.", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "visitChildren", + "returnType": "void", + "signature": [ + { + "name": "visitor", + "description": "", + "type": "void Function(RenderObject)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_reportException", + "returnType": "void", + "signature": [ + { + "name": "method", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "exception", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stack", + "description": "", + "type": "StackTrace", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "attach", + "returnType": "void", + "signature": [ + { + "name": "owner", + "description": "", + "type": "PipelineOwner", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "detach", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_debugRelayoutBoundaryAlreadyMarkedNeedsLayout", + "returnType": "bool", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "markParentNeedsLayout", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object's layout information as dirty, and then defer to\n the parent.\n\n This function should only be called from [markNeedsLayout] or\n [markNeedsLayoutForSizedByParentChange] implementations of subclasses that\n introduce more reasons for deferring the handling of dirty layout to the\n parent. See [markNeedsLayout] for details.\n\n Only call this if [parent] is not null.", + "annotations": [ + "@protected" + ] + }, + { + "name": "markNeedsLayoutForSizedByParentChange", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object's layout information as dirty (like\n [markNeedsLayout]), and additionally also handle any necessary work to\n handle the case where [sizedByParent] has changed value.\n\n This should be called whenever [sizedByParent] might have changed.\n\n Only call this if [parent] is not null.", + "annotations": [] + }, + { + "name": "scheduleInitialLayout", + "returnType": "void", + "signature": [], + "features": [], + "description": " Bootstrap the rendering pipeline by scheduling the very first layout.\n\n Requires this render object to be attached and that this render object\n is the root of the render tree.\n\n See [RenderView] for an example of how this function is used.", + "annotations": [] + }, + { + "name": "_layoutWithoutResize", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "layout", + "returnType": "void", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "Constraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "parentUsesSize", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Compute the layout for this render object.\n\n This method is the main entry point for parents to ask their children to\n update their layout information. The parent passes a constraints object,\n which informs the child as to which layouts are permissible. The child is\n required to obey the given constraints.\n\n If the parent reads information computed during the child's layout, the\n parent must pass true for `parentUsesSize`. In that case, the parent will\n be marked as needing layout whenever the child is marked as needing layout\n because the parent's layout information depends on the child's layout\n information. If the parent uses the default value (false) for\n `parentUsesSize`, the child can change its layout information (subject to\n the given constraints) without informing the parent.\n\n Subclasses should not override [layout] directly. Instead, they should\n override [performResize] and/or [performLayout]. The [layout] method\n delegates the actual work to [performResize] and [performLayout].\n\n The parent's [performLayout] method should call the [layout] of all its\n children unconditionally. It is the [layout] method's responsibility (as\n implemented here) to return early if the child does not need to do any\n work to update its layout information.", + "annotations": [ + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "invokeLayoutCallback", + "returnType": "void", + "signature": [ + { + "name": "callback", + "description": "", + "type": "void Function(T)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Allows mutations to be made to this object's child list (and any\n descendants) as well as to any other dirty nodes in the render tree owned\n by the same [PipelineOwner] as this object. The `callback` argument is\n invoked synchronously, and the mutations are allowed only during that\n callback's execution.\n\n This exists to allow child lists to be built on-demand during layout (e.g.\n based on the object's size), and to enable nodes to be moved around the\n tree as this happens (e.g. to handle [GlobalKey] reparenting), while still\n ensuring that any particular node is only laid out once per frame.\n\n Calling this function disables a number of assertions that are intended to\n catch likely bugs. As such, using this function is generally discouraged.\n\n This function can only be called during layout.", + "annotations": [ + "@protected" + ] + }, + { + "name": "debugRegisterRepaintBoundaryPaint", + "returnType": "void", + "signature": [ + { + "name": "includedParent", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "includedChild", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Called, in debug mode, if [isRepaintBoundary] is true, when either the\n this render object or its parent attempt to paint.\n\n This can be used to record metrics about whether the node should actually\n be a repaint boundary.", + "annotations": [] + }, + { + "name": "updateCompositedLayer", + "returnType": "OffsetLayer", + "signature": [ + { + "name": "oldLayer", + "description": "", + "type": "OffsetLayer?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Update the composited layer owned by this render object.\n\n This method is called by the framework when [isRepaintBoundary] is true.\n\n If [oldLayer] is `null`, this method must return a new [OffsetLayer]\n (or subtype thereof). If [oldLayer] is not `null`, then this method must\n reuse the layer instance that is provided - it is an error to create a new\n layer in this instance. The layer will be disposed by the framework when\n either the render object is disposed or if it is no longer a repaint\n boundary.\n\n The [OffsetLayer.offset] property will be managed by the framework and\n must not be updated by this method.\n\n If a property of the composited layer needs to be updated, the render object\n must call [markNeedsCompositedLayerUpdate] which will schedule this method\n to be called without repainting children. If this widget was marked as\n needing to paint and needing a composited layer update, this method is only\n called once.", + "annotations": [] + }, + { + "name": "markNeedsCompositingBitsUpdate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark the compositing state for this render object as dirty.\n\n This is called to indicate that the value for [needsCompositing] needs to\n be recomputed during the next [PipelineOwner.flushCompositingBits] engine\n phase.\n\n When the subtree is mutated, we need to recompute our\n [needsCompositing] bit, and some of our ancestors need to do the\n same (in case ours changed in a way that will change theirs). To\n this end, [adoptChild] and [dropChild] call this method, and, as\n necessary, this method calls the parent's, etc, walking up the\n tree to mark all the nodes that need updating.\n\n This method does not schedule a rendering frame, because since\n it cannot be the case that _only_ the compositing bits changed,\n something else will have scheduled a frame for us.", + "annotations": [] + }, + { + "name": "_updateCompositingBits", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "markNeedsPaint", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object as having changed its visual appearance.\n\n Rather than eagerly updating this render object's display list\n in response to writes, we instead mark the render object as needing to\n paint, which schedules a visual update. As part of the visual update, the\n rendering pipeline will give this render object an opportunity to update\n its display list.\n\n This mechanism batches the painting work so that multiple sequential\n writes are coalesced, removing redundant computation.\n\n Once [markNeedsPaint] has been called on a render object,\n [debugNeedsPaint] returns true for that render object until just after\n the pipeline owner has called [paint] on the render object.\n\n See also:\n\n * [RepaintBoundary], to scope a subtree of render objects to their own\n layer, thus limiting the number of nodes that [markNeedsPaint] must mark\n dirty.", + "annotations": [] + }, + { + "name": "markNeedsCompositedLayerUpdate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object as having changed a property on its composited\n layer.\n\n Render objects that have a composited layer have [isRepaintBoundary] equal\n to true may update the properties of that composited layer without repainting\n their children. If this render object is a repaint boundary but does\n not yet have a composited layer created for it, this method will instead\n mark the nearest repaint boundary parent as needing to be painted.\n\n If this method is called on a render object that is not a repaint boundary\n or is a repaint boundary but hasn't been composited yet, it is equivalent\n to calling [markNeedsPaint].\n\n See also:\n\n * [RenderOpacity], which uses this method when its opacity is updated to\n update the layer opacity without repainting children.", + "annotations": [] + }, + { + "name": "_skippedPaintingOnLayer", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "scheduleInitialPaint", + "returnType": "void", + "signature": [ + { + "name": "rootLayer", + "description": "", + "type": "ContainerLayer", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Bootstrap the rendering pipeline by scheduling the very first paint.\n\n Requires that this render object is attached, is the root of the render\n tree, and has a composited layer.\n\n See [RenderView] for an example of how this function is used.", + "annotations": [] + }, + { + "name": "replaceRootLayer", + "returnType": "void", + "signature": [ + { + "name": "rootLayer", + "description": "", + "type": "OffsetLayer", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Replace the layer. This is only valid for the root of a render\n object subtree (whatever object [scheduleInitialPaint] was\n called on).\n\n This might be called if, e.g., the device pixel ratio changed.", + "annotations": [] + }, + { + "name": "_paintWithContext", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "paint", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "paintsChild", + "returnType": "bool", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Whether the given child would be painted if [paint] were called.\n\n Some RenderObjects skip painting their children if they are configured to\n not produce any visible effects. For example, a [RenderOffstage] with\n its `offstage` property set to true, or a [RenderOpacity] with its opacity\n value set to zero.\n\n In these cases, the parent may still supply a non-zero matrix in\n [applyPaintTransform] to inform callers about where it would paint the\n child if the child were painted at all. Alternatively, the parent may\n supply a zeroed out matrix if it would not otherwise be able to determine\n a valid matrix for the child and thus cannot meaningfully determine where\n the child would paint.", + "annotations": [] + }, + { + "name": "getTransformTo", + "returnType": "Matrix4", + "signature": [ + { + "name": "target", + "description": "", + "type": "RenderObject?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " {@template flutter.rendering.RenderObject.getTransformTo}\n Applies the paint transform from this [RenderObject] to the `target`\n [RenderObject].\n\n Returns a matrix that maps the local paint coordinate system to the\n coordinate system of `target`, or a [Matrix4.zero] if the paint transform\n can not be computed.\n\n This method throws an exception when the `target` is not in the same render\n tree as this [RenderObject], as the behavior is undefined.\n\n This method ignores [RenderObject.paintsChild]. This means it will still\n try to compute the paint transform even if this [RenderObject] or\n `target` is currently not visible.\n\n If `target` is null, this method returns a matrix that maps from the\n local paint coordinate system to the coordinate system of the\n [PipelineOwner.rootNode].\n {@endtemplate}\n\n For the render tree owned by the [RendererBinding] (i.e. for the main\n render tree displayed on the device) this means that this method maps to\n the global coordinate system in logical pixels. To get physical pixels,\n use [applyPaintTransform] from the [RenderView] to further transform the\n coordinate.", + "annotations": [] + }, + { + "name": "describeApproximatePaintClip", + "returnType": "Rect?", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a rect in this object's coordinate system that describes\n the approximate bounding box of the clip rect that would be\n applied to the given child during the paint phase, if any.\n\n Returns null if the child would not be clipped.\n\n This is used in the semantics phase to avoid including children\n that are not physically visible.\n\n RenderObjects that respect a [Clip] behavior when painting _must_ respect\n that same behavior when describing this value. For example, if passing\n [Clip.none] to [PaintingContext.pushClipRect] as the `clipBehavior`, then\n the implementation of this method must return null.", + "annotations": [] + }, + { + "name": "describeSemanticsClip", + "returnType": "Rect?", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a rect in this object's coordinate system that describes\n which [SemanticsNode]s produced by the `child` should be included in the\n semantics tree. [SemanticsNode]s from the `child` that are positioned\n outside of this rect will be dropped. Child [SemanticsNode]s that are\n positioned inside this rect, but outside of [describeApproximatePaintClip]\n will be included in the tree marked as hidden. Child [SemanticsNode]s\n that are inside of both rect will be included in the tree as regular\n nodes.\n\n This method only returns a non-null value if the semantics clip rect\n is different from the rect returned by [describeApproximatePaintClip].\n If the semantics clip rect and the paint clip rect are the same, this\n method returns null.\n\n A viewport would typically implement this method to include semantic nodes\n in the semantics tree that are currently hidden just before the leading\n or just after the trailing edge. These nodes have to be included in the\n semantics tree to implement implicit accessibility scrolling on iOS where\n the viewport scrolls implicitly when moving the accessibility focus from\n the last visible node in the viewport to the first hidden one.\n\n See also:\n\n * [RenderViewportBase.cacheExtent], used by viewports to extend their\n semantics clip beyond their approximate paint clip.", + "annotations": [] + }, + { + "name": "scheduleInitialSemantics", + "returnType": "void", + "signature": [], + "features": [], + "description": " Bootstrap the semantics reporting mechanism by marking this node\n as needing a semantics update.\n\n Requires that this render object is attached, and is the root of\n the render tree.\n\n See [RendererBinding] for an example of how this function is used.", + "annotations": [] + }, + { + "name": "describeSemanticsConfiguration", + "returnType": "void", + "signature": [ + { + "name": "config", + "description": "", + "type": "SemanticsConfiguration", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Report the semantics of this node, for example for accessibility purposes.\n\n This method should be overridden by subclasses that have interesting\n semantic information.\n\n The given [SemanticsConfiguration] object is mutable and should be\n annotated in a manner that describes the current state. No reference\n should be kept to that object; mutating it outside of the context of the\n [describeSemanticsConfiguration] call (for example as a result of\n asynchronous computation) will at best have no useful effect and at worse\n will cause crashes as the data will be in an inconsistent state.\n\n {@tool snippet}\n\n The following snippet will describe the node as a button that responds to\n tap actions.\n\n ```dart\n abstract class SemanticButtonRenderObject extends RenderObject {\n @override\n void describeSemanticsConfiguration(SemanticsConfiguration config) {\n super.describeSemanticsConfiguration(config);\n config\n ..onTap = _handleTap\n ..label = 'I am a button'\n ..isButton = true;\n }\n\n void _handleTap() {\n // Do something.\n }\n }\n ```\n {@end-tool}", + "annotations": [ + "@protected" + ] + }, + { + "name": "sendSemanticsEvent", + "returnType": "void", + "signature": [ + { + "name": "semanticsEvent", + "description": "", + "type": "SemanticsEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Sends a [SemanticsEvent] associated with this render object's [SemanticsNode].\n\n If this render object has no semantics information, the first parent\n render object with a non-null semantic node is used.\n\n If semantics are disabled, no events are dispatched.\n\n See [SemanticsNode.sendEvent] for a full description of the behavior.", + "annotations": [] + }, + { + "name": "clearSemantics", + "returnType": "void", + "signature": [], + "features": [], + "description": " Removes all semantics from this render object and its descendants.\n\n Should only be called on objects whose [parent] is not a [RenderObject].\n\n Override this method if you instantiate new [SemanticsNode]s in an\n overridden [assembleSemanticsNode] method, to dispose of those nodes.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "markNeedsSemanticsUpdate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this node as needing an update to its semantics description.\n\n This must be called whenever the semantics configuration of this\n [RenderObject] as annotated by [describeSemanticsConfiguration] changes in\n any way to update the semantics tree.", + "annotations": [] + }, + { + "name": "visitChildrenForSemantics", + "returnType": "void", + "signature": [ + { + "name": "visitor", + "description": "", + "type": "void Function(RenderObject)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "assembleSemanticsNode", + "returnType": "void", + "signature": [ + { + "name": "node", + "description": "", + "type": "SemanticsNode", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "config", + "description": "", + "type": "SemanticsConfiguration", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "children", + "description": "", + "type": "Iterable", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Assemble the [SemanticsNode] for this [RenderObject].\n\n If [describeSemanticsConfiguration] sets\n [SemanticsConfiguration.isSemanticBoundary] to true, this method is called\n with the `node` created for this [RenderObject], the `config` to be\n applied to that node and the `children` [SemanticsNode]s that descendants\n of this RenderObject have generated.\n\n By default, the method will annotate `node` with `config` and add the\n `children` to it.\n\n Subclasses can override this method to add additional [SemanticsNode]s\n to the tree. If new [SemanticsNode]s are instantiated in this method\n they must be disposed in [clearSemantics].", + "annotations": [] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "showOnScreen", + "returnType": "void", + "signature": [ + { + "name": "descendant", + "description": "", + "type": "RenderObject?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "rect", + "description": "", + "type": "Rect?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "duration", + "description": "", + "type": "Duration", + "named": true, + "required": false, + "defaultValue": "Duration.zero", + "annotations": [] + }, + { + "name": "curve", + "description": "", + "type": "Curve", + "named": true, + "required": false, + "defaultValue": "Curves.ease", + "annotations": [] + } + ], + "features": [], + "description": " Attempt to make (a portion of) this or a descendant [RenderObject] visible\n on screen.\n\n If `descendant` is provided, that [RenderObject] is made visible. If\n `descendant` is omitted, this [RenderObject] is made visible.\n\n The optional `rect` parameter describes which area of that [RenderObject]\n should be shown on screen. If `rect` is null, the entire\n [RenderObject] (as defined by its [paintBounds]) will be revealed. The\n `rect` parameter is interpreted relative to the coordinate system of\n `descendant` if that argument is provided and relative to this\n [RenderObject] otherwise.\n\n The `duration` parameter can be set to a non-zero value to bring the\n target object on screen in an animation defined by `curve`.\n\n See also:\n\n * [RenderViewportBase.showInViewport], which [RenderViewportBase] and\n [SingleChildScrollView] delegate this method to.", + "annotations": [] + }, + { + "name": "describeForError", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle", + "named": true, + "required": false, + "defaultValue": "DiagnosticsTreeStyle.shallow", + "annotations": [] + } + ], + "features": [], + "description": " Adds a debug representation of a [RenderObject] optimized for including in\n error messages.\n\n The default [style] of [DiagnosticsTreeStyle.shallow] ensures that all of\n the properties of the render object are included in the error output but\n none of the children of the object are.\n\n You should always include a RenderObject in an error message if it is the\n [RenderObject] causing the failure or contract violation of the error.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_debugUltimatePreviousSiblingOf", + "returnType": "bool", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "equals", + "description": "", + "type": "RenderBox?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_debugUltimateNextSiblingOf", + "returnType": "bool", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "equals", + "description": "", + "type": "RenderBox?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "debugValidateChild", + "returnType": "bool", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Checks whether the given render object has the correct [runtimeType] to be\n a child of this render object.\n\n Does nothing if assertions are disabled.\n\n Always returns true.", + "annotations": [] + }, + { + "name": "_insertIntoChildList", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "after", + "description": "", + "type": "RenderBox?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "insert", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "after", + "description": "", + "type": "RenderBox?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Insert child into this render object's child list after the given child.\n\n If `after` is null, then this inserts the child at the start of the list,\n and the child becomes the new [firstChild].", + "annotations": [] + }, + { + "name": "add", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Append child to the end of this render object's child list.", + "annotations": [] + }, + { + "name": "addAll", + "returnType": "void", + "signature": [ + { + "name": "children", + "description": "", + "type": "List?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add all the children to the end of this render object's child list.", + "annotations": [] + }, + { + "name": "_removeFromChildList", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "remove", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove this child from the child list.\n\n Requires the child to be present in the child list.", + "annotations": [] + }, + { + "name": "removeAll", + "returnType": "void", + "signature": [], + "features": [], + "description": " Remove all their children from this render object's child list.\n\n More efficient than removing them individually.", + "annotations": [] + }, + { + "name": "move", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "after", + "description": "", + "type": "RenderBox?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Move the given `child` in the child list to be after another child.\n\n More efficient than removing and re-adding the child. Requires the child\n to already be in the child list at some position. Pass null for `after` to\n move the child to the start of the child list.", + "annotations": [] + }, + { + "name": "childBefore", + "returnType": "RenderBox?", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " The previous child before the given child in the child list.", + "annotations": [] + }, + { + "name": "childAfter", + "returnType": "RenderBox?", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " The next child after the given child in the child list.", + "annotations": [] + }, + { + "name": "defaultComputeDistanceToFirstActualBaseline", + "returnType": "double?", + "signature": [ + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the baseline of the first child with a baseline.\n\n Useful when the children are displayed vertically in the same order they\n appear in the child list.", + "annotations": [] + }, + { + "name": "defaultComputeDistanceToHighestActualBaseline", + "returnType": "double?", + "signature": [ + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the minimum baseline value among every child.\n\n Useful when the vertical position of the children isn't determined by the\n order in the child list.", + "annotations": [] + }, + { + "name": "defaultHitTestChildren", + "returnType": "bool", + "signature": [ + { + "name": "result", + "description": "", + "type": "BoxHitTestResult", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "Offset", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Performs a hit test on each child by walking the child list backwards.\n\n Stops walking once after the first child reports that it contains the\n given point. Returns whether any children contain the given point.\n\n See also:\n\n * [defaultPaint], which paints the children appropriate for this\n hit-testing strategy.", + "annotations": [] + }, + { + "name": "defaultPaint", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Paints each child by walking the child list forwards.\n\n See also:\n\n * [defaultHitTestChildren], which implements hit-testing of the children\n in a manner appropriate for this painting strategy.", + "annotations": [] + }, + { + "name": "getChildrenAsList", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list containing the children of this render object.\n\n This function is useful when you need random-access to the children of\n this render object. If you're accessing the children in order, consider\n walking the child list directly.", + "annotations": [] + }, + { + "name": "getCrossSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getMainSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_constraintsChangedSignificantly", + "returnType": "bool", + "signature": [ + { + "name": "newConstraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Checks if constraints have changed significantly (more than 1 pixel difference)", + "annotations": [] + }, + { + "name": "resetOffstage", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "visitOnlyOnStageChildren", + "returnType": "void", + "signature": [ + { + "name": "visitor", + "description": "", + "type": "void Function(RenderObject)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_childConstraints", + "returnType": "BoxConstraints", + "signature": [ + { + "name": "overflowIndicatorSize", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getChildrenMinMainSizes", + "returnType": "Iterable", + "signature": [ + { + "name": "children", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getCrossSizeOfRenderBox", + "returnType": "double", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getIndicatorSize", + "returnType": "double", + "signature": [ + { + "name": "overflowIndicator", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getMainSizeOfRenderBox", + "returnType": "double", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderBox", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_layoutOverflowIndicator", + "returnType": "RenderBox", + "signature": [ + { + "name": "overflowCount", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Since the overflow indicator might change size depending on\n [overflowCount], we need to layout to determine its size.", + "annotations": [] + }, + { + "name": "_performFlexibleLayout", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_spacingExtent", + "returnType": "double", + "signature": [ + { + "name": "childCount", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "RenderBox", + "interfaces": [], + "mixins": [ + "ContainerRenderObjectMixin", + "RenderBoxContainerDefaultsMixin" + ] + }, + { + "filePath": "lib/src/overflow/overflow_rendering.dart", + "name": "RenderObjectExtensions", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [ + { + "name": "isOnstage", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "extension", + "aliasedType": "RenderObject", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/overflow/overflow_view.dart", + "name": "LdOverflowView", + "isNullSafe": true, + "description": " A widget that displays its children in a one-dimensional array until there\n is no more room. If all the children don't fit in the available space, it\n displays an indicator at the end.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, int)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "children", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mainAxisAlignment", + "description": "", + "type": "MainAxisAlignment", + "named": true, + "required": false, + "defaultValue": "MainAxisAlignment.start", + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "description": "", + "type": "CrossAxisAlignment", + "named": true, + "required": false, + "defaultValue": "CrossAxisAlignment.center", + "annotations": [] + }, + { + "name": "direction", + "description": "", + "type": "Axis", + "named": true, + "required": false, + "defaultValue": "Axis.horizontal", + "annotations": [] + }, + { + "name": "spacing", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "children", + "type": "List", + "description": " The widgets below this widget in the tree.\n\n If this list is going to be mutated, it is usually wise to put a [Key] on\n each of the child widgets, so that the framework can match old\n configurations to new configurations and maintain the underlying render\n objects.\n\n Also, a [Widget] in Flutter is immutable, so directly modifying the\n [children] such as `someMultiChildRenderObjectWidget.children.add(...)` or\n as the example code below will result in incorrect behaviors. Whenever the\n children list is modified, a new list object should be provided.\n\n ```dart\n // This code is incorrect.\n class SomeWidgetState extends State {\n final List _children = [];\n\n void someHandler() {\n setState(() {\n _children.add(const ChildWidget());\n });\n }\n\n @override\n Widget build(BuildContext context) {\n // Reusing `List _children` here is problematic.\n return Row(children: _children);\n }\n }\n ```\n\n The following code corrects the problem mentioned above.\n\n ```dart\n class SomeWidgetState extends State {\n final List _children = [];\n\n void someHandler() {\n setState(() {\n // The key here allows Flutter to reuse the underlying render\n // objects even if the children list is recreated.\n _children.add(ChildWidget(key: UniqueKey()));\n });\n }\n\n @override\n Widget build(BuildContext context) {\n // Always create a new list of children as a Widget is immutable.\n return Row(children: _children.toList());\n }\n }\n ```", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "direction", + "type": "Axis", + "description": " The direction to use as the main axis.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "spacing", + "type": "double", + "description": " The amount of space between successive children.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mainAxisAlignment", + "type": "MainAxisAlignment", + "description": " The alignment of the children along the main axis.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "crossAxisAlignment", + "type": "CrossAxisAlignment", + "description": " The alignment of the children along the cross axis.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, int)", + "description": " The builder for the overflow indicator.", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "LdOverflowViewElement", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "createRenderObject", + "returnType": "LdRenderOverflowView", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "updateRenderObject", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "renderObject", + "description": "", + "type": "LdRenderOverflowView", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUnmountRenderObject", + "returnType": "void", + "signature": [ + { + "name": "renderObject", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " This method is called when a RenderObject that was previously\n associated with this widget is removed from the render tree.\n The provided [RenderObject] will be of the same type as the one created by\n this widget's [createRenderObject] method.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "MultiChildRenderObjectWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/overflow/overflow_view.dart", + "name": "LdOverflowViewElement", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "widget", + "description": "", + "type": "LdOverflowView", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_children", + "type": "List", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_forgottenChildren", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "renderObject", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "children", + "type": "Iterable", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_renderObject", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDoingBuild", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_ancestorRenderObjectElement", + "type": "RenderObjectElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "renderObjectAttachingChild", + "type": "Element?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugDoingBuild", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_parent", + "type": "Element?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_notificationTree", + "type": "_NotificationNode?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_slot", + "type": "Object?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_depth", + "type": "int", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_widget", + "type": "Widget?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_owner", + "type": "BuildOwner?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_parentBuildScope", + "type": "BuildScope?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_lifecycleState", + "type": "_ElementLifecycle", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugForgottenChildrenWithGlobalKey", + "type": "Set?", + "description": "", + "features": [ + "final" + ], + "annotations": [ + "@_debugOnly" + ] + }, + { + "name": "_inheritedElements", + "type": "PersistentHashMap?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dependencies", + "type": "Set?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_hadUnsatisfiedDependencies", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dirty", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_inDirtyList", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugBuiltOnce", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "slot", + "type": "Object?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "depth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "Widget", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugIsDefunct", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugIsActive", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "owner", + "type": "BuildOwner?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "buildScope", + "type": "BuildScope", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "size", + "type": "Size?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "dirty", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "insertRenderObjectChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "slot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Insert the given child into [renderObject] at the given slot.\n\n {@template flutter.widgets.RenderObjectElement.insertRenderObjectChild}\n The semantics of `slot` are determined by this element. For example, if\n this element has a single child, the slot should always be null. If this\n element has a list of children, the previous sibling element wrapped in an\n [IndexedSlot] is a convenient value for the slot.\n {@endtemplate}", + "annotations": [ + "@protected" + ] + }, + { + "name": "moveRenderObjectChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "oldSlot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newSlot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Move the given child from the given old slot to the given new slot.\n\n The given child is guaranteed to have [renderObject] as its parent.\n\n {@macro flutter.widgets.RenderObjectElement.insertRenderObjectChild}\n\n This method is only ever called if [updateChild] can end up being called\n with an existing [Element] child and a `slot` that differs from the slot\n that element was previously given. [MultiChildRenderObjectElement] does this,\n for example. [SingleChildRenderObjectElement] does not (since the `slot` is\n always null). An [Element] that has a specific set of slots with each child\n always having the same slot (and where children in different slots are never\n compared against each other for the purposes of updating one slot with the\n element from another slot) would never call this.", + "annotations": [ + "@protected" + ] + }, + { + "name": "removeRenderObjectChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "slot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove the given child from [renderObject].\n\n The given child is guaranteed to have been inserted at the given `slot`\n and have [renderObject] as its parent.", + "annotations": [ + "@protected" + ] + }, + { + "name": "visitChildren", + "returnType": "void", + "signature": [ + { + "name": "visitor", + "description": "", + "type": "void Function(Element)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Calls the argument for each child. Must be overridden by subclasses that\n support having children.\n\n There is no guaranteed order in which the children will be visited, though\n it should be consistent over time.\n\n Calling this during build is dangerous: the child list might still be\n being updated at that point, so the children might not be constructed yet,\n or might be old children that are going to be replaced. This method should\n only be called if it is provable that the children are available.", + "annotations": [] + }, + { + "name": "forgetChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "Element", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove the given child from the element's child list, in preparation for\n the child being reused elsewhere in the element tree.\n\n This updates the child model such that, e.g., [visitChildren] does not\n walk that child anymore.\n\n The element will still have a valid parent when this is called, and the\n child's [Element.slot] value will be valid in the context of that parent.\n After this is called, [deactivateChild] is called to sever the link to\n this object.\n\n The [update] is responsible for updating or creating the new child that\n will replace this [child].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "_debugCheckHasAssociatedRenderObject", + "returnType": "bool", + "signature": [ + { + "name": "newChild", + "description": "", + "type": "Element", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "inflateWidget", + "returnType": "Element", + "signature": [ + { + "name": "newWidget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newSlot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Create an element for the given widget and add it as a child of this\n element in the given slot.\n\n This method is typically called by [updateChild] but can be called\n directly by subclasses that need finer-grained control over creating\n elements.\n\n If the given widget has a global key and an element already exists that\n has a widget with that global key, this function will reuse that element\n (potentially grafting it from another location in the tree or reactivating\n it from the list of inactive elements) rather than creating a new element.\n\n The `newSlot` argument specifies the new value for this element's [slot].\n\n The element returned by this function will already have been mounted and\n will be in the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@pragma('dart2js:tryInline')", + "@pragma('vm:prefer-inline')", + "@pragma('wasm:prefer-inline')" + ] + }, + { + "name": "mount", + "returnType": "void", + "signature": [ + { + "name": "parent", + "description": "", + "type": "Element?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newSlot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add this element to the tree in the given slot of the given parent.\n\n The framework calls this function when a newly created element is added to\n the tree for the first time. Use this method to initialize state that\n depends on having a parent. State that is independent of the parent can\n more easily be initialized in the constructor.\n\n This method transitions the element from the \"initial\" lifecycle state to\n the \"active\" lifecycle state.\n\n Subclasses that override this method are likely to want to also override\n [update], [visitChildren], [RenderObjectElement.insertRenderObjectChild],\n [RenderObjectElement.moveRenderObjectChild], and\n [RenderObjectElement.removeRenderObjectChild].\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.mount(parent, newSlot)`.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "update", + "returnType": "void", + "signature": [ + { + "name": "newWidget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Change the widget used to configure this element.\n\n The framework calls this function when the parent wishes to use a\n different widget to configure this element. The new widget is guaranteed\n to have the same [runtimeType] as the old widget.\n\n This function is called only during the \"active\" lifecycle state.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "_findAncestorRenderObjectElement", + "returnType": "RenderObjectElement?", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_debugCheckCompetingAncestors", + "returnType": "void", + "signature": [ + { + "name": "result", + "description": "", + "type": "List>", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugAncestorTypes", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugParentDataTypes", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugAncestorCulprits", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_findAncestorParentDataElements", + "returnType": "List>", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_debugUpdateRenderObjectOwner", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "performRebuild", + "returnType": "void", + "signature": [], + "features": [], + "description": " Cause the widget to update itself.\n\n Called by [rebuild] after the appropriate checks have been made.\n\n The base implementation only clears the [dirty] flag.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "_performRebuild", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@pragma('dart2js:tryInline')", + "@pragma('vm:prefer-inline')", + "@pragma('wasm:prefer-inline')" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Transition from the \"active\" to the \"inactive\" lifecycle state.\n\n The framework calls this method when a previously active element is moved\n to the list of inactive elements. While in the inactive state, the element\n will not appear on screen. The element can remain in the inactive state\n only until the end of the current animation frame. At the end of the\n animation frame, if the element has not be reactivated, the framework will\n unmount the element.\n\n In case of an uncaught exception when rebuild a widget subtree, the\n framework also calls this method on the failing subtree to make sure the\n widget tree is in a relatively consistent state. The deactivation of such\n subtrees are performed only on a best-effort basis, and the errors thrown\n during deactivation will not be rethrown.\n\n This is indirectly called by [deactivateChild].\n\n See the lifecycle documentation for [Element] for additional information.\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.", + "annotations": [ + "@mustCallSuper", + "@visibleForOverriding" + ] + }, + { + "name": "unmount", + "returnType": "void", + "signature": [], + "features": [], + "description": " Transition from the \"inactive\" to the \"defunct\" lifecycle state.\n\n Called when the framework determines that an inactive element will never\n be reactivated. At the end of each animation frame, the framework calls\n [unmount] on any remaining inactive elements, preventing inactive elements\n from remaining inactive for longer than a single animation frame.\n\n After this function is called, the element will not be incorporated into\n the tree again.\n\n Any resources this element holds should be released at this point. For\n example, [RenderObjectElement.unmount] calls [RenderObject.dispose] and\n nulls out its reference to the render object.\n\n See the lifecycle documentation for [Element] for additional information.\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.unmount()`.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "_updateParentData", + "returnType": "void", + "signature": [ + { + "name": "parentDataWidget", + "description": "", + "type": "ParentDataWidget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "updateSlot", + "returnType": "void", + "signature": [ + { + "name": "newSlot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called by [updateSlotForChild] when the framework needs to change the slot\n that this [Element] occupies in its ancestor.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "attachRenderObject", + "returnType": "void", + "signature": [ + { + "name": "newSlot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add [renderObject] to the render tree at the location specified by `newSlot`.\n\n The default implementation of this function calls\n [attachRenderObject] recursively on each child. The\n [RenderObjectElement.attachRenderObject] override does the actual work of\n adding [renderObject] to the render tree.\n\n The `newSlot` argument specifies the new value for this element's [slot].", + "annotations": [] + }, + { + "name": "detachRenderObject", + "returnType": "void", + "signature": [], + "features": [], + "description": " Remove [renderObject] from the render tree.\n\n The default implementation of this function calls\n [detachRenderObject] recursively on each child. The\n [RenderObjectElement.detachRenderObject] override does the actual work of\n removing [renderObject] from the render tree.\n\n This is called by [deactivateChild].", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Compare two widgets for equality.\n\n When a widget is rebuilt with another that compares equal according\n to `operator ==`, it is assumed that the update is redundant and the\n work to update that branch of the tree is skipped.\n\n It is generally discouraged to override `operator ==` on any widget that\n has children, since a correct implementation would have to defer to the\n children's equality operator also, and that is an O(N²) operation: each\n child would need to itself walk all its children, each step of the tree.\n\n It is sometimes reasonable for a leaf widget (one with no children) to\n implement this method, if rebuilding the widget is known to be much more\n expensive than checking the widgets' parameters for equality and if the\n widget is expected to often be rebuilt with identical parameters.\n\n In general, however, it is more efficient to cache the widgets used\n in a build method if it is known that they will not change.", + "annotations": [ + "@nonVirtual", + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@template flutter.widgets.Element.reassemble}\n Called whenever the application is reassembled during debugging, for\n example during hot reload.\n\n This method should rerun any initialization logic that depends on global\n state, for example, image loading from asset bundles (since the asset\n bundle may have changed).\n\n This function will only be called during development. In release builds,\n the `ext.flutter.reassemble` hook is not available, and so this code will\n never execute.\n\n Implementers should not rely on any ordering for hot reload source update,\n reassemble, and build methods after a hot reload has been initiated. It is\n possible that a [Timer] (e.g. an [Animation]) or a debugging session\n attached to the isolate could trigger a build with reloaded code _before_\n reassemble is called. Code that expects preconditions to be set by\n reassemble after a hot reload must be resilient to being called out of\n order, e.g. by fizzling instead of throwing. That said, once reassemble is\n called, build will be called after it at least once.\n {@endtemplate}\n\n See also:\n\n * [State.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "_debugIsDescendantOf", + "returnType": "bool", + "signature": [ + { + "name": "target", + "description": "", + "type": "Element", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "describeMissingAncestor", + "returnType": "List", + "signature": [ + { + "name": "expectedAncestorType", + "description": "", + "type": "Type", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Adds a description of a specific type of widget missing from the current\n build context's ancestry tree.\n\n You can find an example of using this method in [debugCheckHasMaterial].", + "annotations": [] + }, + { + "name": "describeElement", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle", + "named": true, + "required": false, + "defaultValue": "DiagnosticsTreeStyle.errorProperty", + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Returns a description of the [Element] associated with the current build context.\n\n The `name` is typically something like \"The element being rebuilt was\".\n\n See also:\n\n * [Element.describeElements], which can be used to describe a list of elements.", + "annotations": [] + }, + { + "name": "describeWidget", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle", + "named": true, + "required": false, + "defaultValue": "DiagnosticsTreeStyle.errorProperty", + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Returns a description of the [Widget] associated with the current build context.\n\n The `name` is typically something like \"The widget being rebuilt was\".", + "annotations": [] + }, + { + "name": "describeOwnershipChain", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Adds a description of the ownership chain from a specific [Element]\n to the error report.\n\n The ownership chain is useful for debugging the source of an element.", + "annotations": [] + }, + { + "name": "debugVisitOnstageChildren", + "returnType": "void", + "signature": [ + { + "name": "visitor", + "description": "", + "type": "void Function(Element)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "visitChildElements", + "returnType": "void", + "signature": [ + { + "name": "visitor", + "description": "", + "type": "void Function(Element)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Walks the children of this widget.\n\n {@template flutter.widgets.BuildContext.visitChildElements}\n This is useful for applying changes to children after they are built\n without waiting for the next frame, especially if the children are known,\n and especially if there is exactly one child (as is always the case for\n [StatefulWidget]s or [StatelessWidget]s).\n\n Calling this method is very cheap for build contexts that correspond to\n [StatefulWidget]s or [StatelessWidget]s (O(1), since there's only one\n child).\n\n Calling this method is potentially expensive for build contexts that\n correspond to [RenderObjectWidget]s (O(N) in the number of children).\n\n Calling this method recursively is extremely expensive (O(N) in the number\n of descendants), and should be avoided if possible. Generally it is\n significantly cheaper to use an [InheritedWidget] and have the descendants\n pull data down, than it is to use [visitChildElements] recursively to push\n data down to them.\n {@endtemplate}", + "annotations": [] + }, + { + "name": "updateChild", + "returnType": "Element?", + "signature": [ + { + "name": "child", + "description": "", + "type": "Element?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newWidget", + "description": "", + "type": "Widget?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newSlot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Update the given child with the given new configuration.\n\n This method is the core of the widgets system. It is called each time we\n are to add, update, or remove a child based on an updated configuration.\n\n The `newSlot` argument specifies the new value for this element's [slot].\n\n If the `child` is null, and the `newWidget` is not null, then we have a new\n child for which we need to create an [Element], configured with `newWidget`.\n\n If the `newWidget` is null, and the `child` is not null, then we need to\n remove it because it no longer has a configuration.\n\n If neither are null, then we need to update the `child`'s configuration to\n be the new configuration given by `newWidget`. If `newWidget` can be given\n to the existing child (as determined by [Widget.canUpdate]), then it is so\n given. Otherwise, the old child needs to be disposed and a new child\n created for the new configuration.\n\n If both are null, then we don't have a child and won't have a child, so we\n do nothing.\n\n The [updateChild] method returns the new child, if it had to create one,\n or the child that was passed in, if it just had to update the child, or\n null, if it removed the child and did not replace it.\n\n The following table summarizes the above:\n\n | | **newWidget == null** | **newWidget != null** |\n | :-----------------: | :--------------------- | :---------------------- |\n | **child == null** | Returns null. | Returns new [Element]. |\n | **child != null** | Old child is removed, returns null. | Old child updated if possible, returns child or new [Element]. |\n\n The `newSlot` argument is used only if `newWidget` is not null. If `child`\n is null (or if the old child cannot be updated), then the `newSlot` is\n given to the new [Element] that is created for the child, via\n [inflateWidget]. If `child` is not null (and the old child _can_ be\n updated), then the `newSlot` is given to [updateSlotForChild] to update\n its slot, in case it has moved around since it was last built.\n\n See the [RenderObjectElement] documentation for more information on slots.", + "annotations": [ + "@protected", + "@pragma('dart2js:tryInline')", + "@pragma('vm:prefer-inline')", + "@pragma('wasm:prefer-inline')" + ] + }, + { + "name": "updateChildren", + "returnType": "List", + "signature": [ + { + "name": "oldChildren", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newWidgets", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "forgottenChildren", + "description": "", + "type": "Set?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "slots", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Updates the children of this element to use new widgets.\n\n Attempts to update the given old children list using the given new\n widgets, removing obsolete elements and introducing new ones as necessary,\n and then returns the new child list.\n\n During this function the `oldChildren` list must not be modified. If the\n caller wishes to remove elements from `oldChildren` reentrantly while\n this function is on the stack, the caller can supply a `forgottenChildren`\n argument, which can be modified while this function is on the stack.\n Whenever this function reads from `oldChildren`, this function first\n checks whether the child is in `forgottenChildren`. If it is, the function\n acts as if the child was not in `oldChildren`.\n\n This function is a convenience wrapper around [updateChild], which updates\n each individual child. If `slots` is non-null, the value for the `newSlot`\n argument of [updateChild] is retrieved from that list using the index that\n the currently processed `child` corresponds to in the `newWidgets` list\n (`newWidgets` and `slots` must have the same length). If `slots` is null,\n an [IndexedSlot] is used as the value for the `newSlot` argument.\n In that case, [IndexedSlot.index] is set to the index that the currently\n processed `child` corresponds to in the `newWidgets` list and\n [IndexedSlot.value] is set to the [Element] of the previous widget in that\n list (or null if it is the first child).\n\n When the [slot] value of an [Element] changes, its\n associated [renderObject] needs to move to a new position in the child\n list of its parents. If that [RenderObject] organizes its children in a\n linked list (as is done by the [ContainerRenderObjectMixin]) this can\n be implemented by re-inserting the child [RenderObject] into the\n list after the [RenderObject] associated with the [Element] provided as\n [IndexedSlot.value] in the [slot] object.\n\n Using the previous sibling as a [slot] is not enough, though, because\n child [RenderObject]s are only moved around when the [slot] of their\n associated [RenderObjectElement]s is updated. When the order of child\n [Element]s is changed, some elements in the list may move to a new index\n but still have the same previous sibling. For example, when\n `[e1, e2, e3, e4]` is changed to `[e1, e3, e4, e2]` the element e4\n continues to have e3 as a previous sibling even though its index in the list\n has changed and its [RenderObject] needs to move to come before e2's\n [RenderObject]. In order to trigger this move, a new [slot] value needs to\n be assigned to its [Element] whenever its index in its\n parent's child list changes. Using an [IndexedSlot] achieves\n exactly that and also ensures that the underlying parent [RenderObject]\n knows where a child needs to move to in a linked list by providing its new\n previous sibling.", + "annotations": [ + "@protected" + ] + }, + { + "name": "_debugRemoveGlobalKeyReservation", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "Element", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "updateSlotForChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "Element", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newSlot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Change the slot that the given child occupies in its parent.\n\n Called by [MultiChildRenderObjectElement], and other [RenderObjectElement]\n subclasses that have multiple children, when child moves from one position\n to another in this element's child list.", + "annotations": [ + "@protected" + ] + }, + { + "name": "_updateDepth", + "returnType": "void", + "signature": [ + { + "name": "parentDepth", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateBuildScopeRecursively", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_retakeInactiveElement", + "returnType": "Element?", + "signature": [ + { + "name": "key", + "description": "", + "type": "GlobalKey>", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newWidget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_debugCheckForCycles", + "returnType": "void", + "signature": [ + { + "name": "newChild", + "description": "", + "type": "Element", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "deactivateChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "Element", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Move the given element to the list of inactive elements and detach its\n render object from the render tree.\n\n This method stops the given element from being a child of this element by\n detaching its render object from the render tree and moving the element to\n the list of inactive elements.\n\n This method (indirectly) calls [deactivate] on the child.\n\n The caller is responsible for removing the child from its child model.\n Typically [deactivateChild] is called by the element itself while it is\n updating its child model; however, during [GlobalKey] reparenting, the new\n parent proactively calls the old parent's [deactivateChild], first using\n [forgetChild] to cause the old parent to update its child model.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "_deactivateFailedChildSilently", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "Element", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_activateWithParent", + "returnType": "void", + "signature": [ + { + "name": "parent", + "description": "", + "type": "Element", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newSlot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Transition from the \"inactive\" to the \"active\" lifecycle state.\n\n The framework calls this method when a previously deactivated element has\n been reincorporated into the tree. The framework does not call this method\n the first time an element becomes active (i.e., from the \"initial\"\n lifecycle state). Instead, the framework calls [mount] in that situation.\n\n See the lifecycle documentation for [Element] for additional information.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.", + "annotations": [ + "@mustCallSuper", + "@visibleForOverriding" + ] + }, + { + "name": "_ensureDeactivated", + "returnType": "void", + "signature": [], + "features": [], + "description": " Removes dependencies and sets the lifecycle state of this [Element] to\n inactive.\n\n This method is immediately called after [Element.deactivate], even if that\n call throws an exception.", + "annotations": [] + }, + { + "name": "debugDeactivated", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called, in debug mode, after children have been deactivated (see [deactivate]).\n\n This method is not called in release builds.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "debugExpectsRenderObjectForSlot", + "returnType": "bool", + "signature": [ + { + "name": "slot", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Whether the child in the provided `slot` (or one of its descendants) must\n insert a [RenderObject] into its ancestor [RenderObjectElement] by calling\n [RenderObjectElement.insertRenderObjectChild] on it.\n\n This method is used to define non-rendering zones in the element tree (see\n [WidgetsBinding] for an explanation of rendering and non-rendering zones):\n\n Most branches of the [Element] tree are expected to eventually insert a\n [RenderObject] into their [RenderObjectElement] ancestor to construct the\n render tree. However, there is a notable exception: an [Element] may\n expect that the occupant of a certain child slot creates a new independent\n render tree and therefore is not allowed to insert a render object into\n the existing render tree. Those elements must return false from this\n method for the slot in question to signal to the child in that slot that\n it must not call [RenderObjectElement.insertRenderObjectChild] on its\n ancestor.\n\n As an example, the element backing the [ViewAnchor] returns false from\n this method for the [ViewAnchor.view] slot to enforce that it is occupied\n by e.g. a [View] widget, which will ultimately bootstrap a separate\n render tree for that view. Another example is the [ViewCollection] widget,\n which returns false for all its slots for the same reason.\n\n Overriding this method is not common, as elements behaving in the way\n described above are rare.", + "annotations": [] + }, + { + "name": "findRenderObject", + "returnType": "RenderObject?", + "signature": [], + "features": [ + "abstract" + ], + "description": " The current [RenderObject] for the widget. If the widget is a\n [RenderObjectWidget], this is the render object that the widget created\n for itself. Otherwise, it is the render object of the first descendant\n [RenderObjectWidget].\n\n This method will only return a valid result after the build phase is\n complete. It is therefore not valid to call this from a build method.\n It should only be called from interaction event handlers (e.g.\n gesture callbacks) or layout or paint callbacks. It is also not valid to\n call if [State.mounted] returns false.\n\n If the render object is a [RenderBox], which is the common case, then the\n size of the render object can be obtained from the [size] getter. This is\n only valid after the layout phase, and should therefore only be examined\n from paint callbacks or interaction event handlers (e.g. gesture\n callbacks).\n\n For details on the different phases of a frame, see the discussion at\n [WidgetsBinding.drawFrame].\n\n Calling this method is theoretically relatively expensive (O(N) in the\n depth of the tree), but in practice is usually cheap because the tree\n usually has many render objects and therefore the distance to the nearest\n render object is usually short.", + "annotations": [] + }, + { + "name": "_debugCheckStateIsActiveForAncestorLookup", + "returnType": "bool", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "doesDependOnInheritedElement", + "returnType": "bool", + "signature": [ + { + "name": "ancestor", + "description": "", + "type": "InheritedElement", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns `true` if [dependOnInheritedElement] was previously called with [ancestor].", + "annotations": [ + "@protected" + ] + }, + { + "name": "dependOnInheritedElement", + "returnType": "InheritedWidget", + "signature": [ + { + "name": "ancestor", + "description": "", + "type": "InheritedElement", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "aspect", + "description": "", + "type": "Object?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Registers this build context with [ancestor] such that when\n [ancestor]'s widget changes this build context is rebuilt.\n\n Returns `ancestor.widget`.\n\n This method is rarely called directly. Most applications should use\n [dependOnInheritedWidgetOfExactType], which calls this method after finding\n the appropriate [InheritedElement] ancestor.\n\n All of the qualifications about when [dependOnInheritedWidgetOfExactType] can\n be called apply to this method as well.", + "annotations": [] + }, + { + "name": "dependOnInheritedWidgetOfExactType", + "returnType": "T?", + "signature": [ + { + "name": "aspect", + "description": "", + "type": "Object?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Returns the nearest widget of the given type `T` and creates a dependency\n on it, or null if no appropriate widget is found.\n\n The widget found will be a concrete [InheritedWidget] subclass, and\n calling [dependOnInheritedWidgetOfExactType] registers this build context\n with the returned widget. When that widget changes (or a new widget of\n that type is introduced, or the widget goes away), this build context is\n rebuilt so that it can obtain new values from that widget.\n\n {@template flutter.widgets.BuildContext.dependOnInheritedWidgetOfExactType}\n This is typically called implicitly from `of()` static methods, e.g.\n [Theme.of].\n\n This method should not be called from widget constructors or from\n [State.initState] methods, because those methods would not get called\n again if the inherited value were to change. To ensure that the widget\n correctly updates itself when the inherited value changes, only call this\n (directly or indirectly) from build methods, layout and paint callbacks,\n or from [State.didChangeDependencies] (which is called immediately after\n [State.initState]).\n\n This method should not be called from [State.dispose] because the element\n tree is no longer stable at that time. To refer to an ancestor from that\n method, save a reference to the ancestor in [State.didChangeDependencies].\n It is safe to use this method from [State.deactivate], which is called\n whenever the widget is removed from the tree.\n\n It is also possible to call this method from interaction event handlers\n (e.g. gesture callbacks) or timers, to obtain a value once, as long as\n that value is not cached and/or reused later.\n\n Calling this method is O(1) with a small constant factor, but will lead to\n the widget being rebuilt more often.\n\n Once a widget registers a dependency on a particular type by calling this\n method, it will be rebuilt, and [State.didChangeDependencies] will be\n called, whenever changes occur relating to that widget until the next time\n the widget or one of its ancestors is moved (for example, because an\n ancestor is added or removed).\n\n The [aspect] parameter is only used when `T` is an\n [InheritedWidget] subclasses that supports partial updates, like\n [InheritedModel]. It specifies what \"aspect\" of the inherited\n widget this context depends on.\n {@endtemplate}", + "annotations": [] + }, + { + "name": "getInheritedWidgetOfExactType", + "returnType": "T?", + "signature": [], + "features": [ + "abstract" + ], + "description": " Returns the nearest widget of the given [InheritedWidget] subclass `T` or\n null if an appropriate ancestor is not found.\n\n {@template flutter.widgets.BuildContext.getInheritedWidgetOfExactType}\n This method does not introduce a dependency the way that the more typical\n [dependOnInheritedWidgetOfExactType] does, so this context will not be\n rebuilt if the [InheritedWidget] changes. This function is meant for those\n uncommon use cases where a dependency is undesirable.\n\n This method should not be called from [State.dispose] because the element\n tree is no longer stable at that time. To refer to an ancestor from that\n method, save a reference to the ancestor in [State.didChangeDependencies].\n It is safe to use this method from [State.deactivate], which is called\n whenever the widget is removed from the tree.\n\n It is also possible to call this method from interaction event handlers\n (e.g. gesture callbacks) or timers, to obtain a value once, as long as\n that value is not cached and/or reused later.\n\n Calling this method is O(1) with a small constant factor.\n {@endtemplate}", + "annotations": [] + }, + { + "name": "getElementForInheritedWidgetOfExactType", + "returnType": "InheritedElement?", + "signature": [], + "features": [ + "abstract" + ], + "description": " Obtains the element corresponding to the nearest widget of the given type `T`,\n which must be the type of a concrete [InheritedWidget] subclass.\n\n Returns null if no such element is found.\n\n {@template flutter.widgets.BuildContext.getElementForInheritedWidgetOfExactType}\n Calling this method is O(1) with a small constant factor.\n\n This method does not establish a relationship with the target in the way\n that [dependOnInheritedWidgetOfExactType] does.\n\n This method should not be called from [State.dispose] because the element\n tree is no longer stable at that time. To refer to an ancestor from that\n method, save a reference to the ancestor by calling\n [dependOnInheritedWidgetOfExactType] in [State.didChangeDependencies]. It is\n safe to use this method from [State.deactivate], which is called whenever\n the widget is removed from the tree.\n {@endtemplate}", + "annotations": [] + }, + { + "name": "attachNotificationTree", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called in [Element.mount] and [Element.activate] to register this element in\n the notification tree.\n\n This method is only exposed so that [NotifiableElementMixin] can be implemented.\n Subclasses of [Element] that wish to respond to notifications should mix that\n in instead.\n\n See also:\n * [NotificationListener], a widget that allows listening to notifications.", + "annotations": [ + "@protected" + ] + }, + { + "name": "_updateInheritance", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "findAncestorWidgetOfExactType", + "returnType": "T?", + "signature": [], + "features": [ + "abstract" + ], + "description": " Returns the nearest ancestor widget of the given type `T`, which must be the\n type of a concrete [Widget] subclass.\n\n {@template flutter.widgets.BuildContext.findAncestorWidgetOfExactType}\n In general, [dependOnInheritedWidgetOfExactType] is more useful, since\n inherited widgets will trigger consumers to rebuild when they change. This\n method is appropriate when used in interaction event handlers (e.g.\n gesture callbacks) or for performing one-off tasks such as asserting that\n you have or don't have a widget of a specific type as an ancestor. The\n return value of a Widget's build method should not depend on the value\n returned by this method, because the build context will not rebuild if the\n return value of this method changes. This could lead to a situation where\n data used in the build method changes, but the widget is not rebuilt.\n\n Calling this method is relatively expensive (O(N) in the depth of the\n tree). Only call this method if the distance from this widget to the\n desired ancestor is known to be small and bounded.\n\n This method should not be called from [State.deactivate] or [State.dispose]\n because the widget tree is no longer stable at that time. To refer to\n an ancestor from one of those methods, save a reference to the ancestor\n by calling [findAncestorWidgetOfExactType] in [State.didChangeDependencies].\n\n Returns null if a widget of the requested type does not appear in the\n ancestors of this context.\n {@endtemplate}", + "annotations": [] + }, + { + "name": "findAncestorStateOfType", + "returnType": "T?", + "signature": [], + "features": [ + "abstract" + ], + "description": " Returns the [State] object of the nearest ancestor [StatefulWidget] widget\n that is an instance of the given type `T`.\n\n {@template flutter.widgets.BuildContext.findAncestorStateOfType}\n This should not be used from build methods, because the build context will\n not be rebuilt if the value that would be returned by this method changes.\n In general, [dependOnInheritedWidgetOfExactType] is more appropriate for such\n cases. This method is useful for changing the state of an ancestor widget in\n a one-off manner, for example, to cause an ancestor scrolling list to\n scroll this build context's widget into view, or to move the focus in\n response to user interaction.\n\n In general, though, consider using a callback that triggers a stateful\n change in the ancestor rather than using the imperative style implied by\n this method. This will usually lead to more maintainable and reusable code\n since it decouples widgets from each other.\n\n Calling this method is relatively expensive (O(N) in the depth of the\n tree). Only call this method if the distance from this widget to the\n desired ancestor is known to be small and bounded.\n\n This method should not be called from [State.deactivate] or [State.dispose]\n because the widget tree is no longer stable at that time. To refer to\n an ancestor from one of those methods, save a reference to the ancestor\n by calling [findAncestorStateOfType] in [State.didChangeDependencies].\n {@endtemplate}\n\n {@tool snippet}\n\n ```dart\n ScrollableState? scrollable = context.findAncestorStateOfType();\n ```\n {@end-tool}", + "annotations": [] + }, + { + "name": "findRootAncestorStateOfType", + "returnType": "T?", + "signature": [], + "features": [ + "abstract" + ], + "description": " Returns the [State] object of the furthest ancestor [StatefulWidget] widget\n that is an instance of the given type `T`.\n\n {@template flutter.widgets.BuildContext.findRootAncestorStateOfType}\n Functions the same way as [findAncestorStateOfType] but keeps visiting subsequent\n ancestors until there are none of the type instance of `T` remaining.\n Then returns the last one found.\n\n This operation is O(N) as well though N is the entire widget tree rather than\n a subtree.\n {@endtemplate}", + "annotations": [] + }, + { + "name": "findAncestorRenderObjectOfType", + "returnType": "T?", + "signature": [], + "features": [ + "abstract" + ], + "description": " Returns the [RenderObject] object of the nearest ancestor [RenderObjectWidget] widget\n that is an instance of the given type `T`.\n\n {@template flutter.widgets.BuildContext.findAncestorRenderObjectOfType}\n This should not be used from build methods, because the build context will\n not be rebuilt if the value that would be returned by this method changes.\n In general, [dependOnInheritedWidgetOfExactType] is more appropriate for such\n cases. This method is useful only in esoteric cases where a widget needs\n to cause an ancestor to change its layout or paint behavior. For example,\n it is used by [Material] so that [InkWell] widgets can trigger the ink\n splash on the [Material]'s actual render object.\n\n Calling this method is relatively expensive (O(N) in the depth of the\n tree). Only call this method if the distance from this widget to the\n desired ancestor is known to be small and bounded.\n\n This method should not be called from [State.deactivate] or [State.dispose]\n because the widget tree is no longer stable at that time. To refer to\n an ancestor from one of those methods, save a reference to the ancestor\n by calling [findAncestorRenderObjectOfType] in [State.didChangeDependencies].\n {@endtemplate}", + "annotations": [] + }, + { + "name": "visitAncestorElements", + "returnType": "void", + "signature": [ + { + "name": "visitor", + "description": "", + "type": "bool Function(Element)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Walks the ancestor chain, starting with the parent of this build context's\n widget, invoking the argument for each ancestor.\n\n {@template flutter.widgets.BuildContext.visitAncestorElements}\n The callback is given a reference to the ancestor widget's corresponding\n [Element] object. The walk stops when it reaches the root widget or when\n the callback returns false. The callback must not return null.\n\n This is useful for inspecting the widget tree.\n\n Calling this method is relatively expensive (O(N) in the depth of the tree).\n\n This method should not be called from [State.deactivate] or [State.dispose]\n because the element tree is no longer stable at that time. To refer to\n an ancestor from one of those methods, save a reference to the ancestor\n by calling [visitAncestorElements] in [State.didChangeDependencies].\n {@endtemplate}", + "annotations": [] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this element changes.\n\n The [dependOnInheritedWidgetOfExactType] registers this element as depending on\n inherited information of the given type. When the information of that type\n changes at this location in the tree (e.g., because the [InheritedElement]\n updated to a new [InheritedWidget] and\n [InheritedWidget.updateShouldNotify] returned true), the framework calls\n this function to notify this element of the change.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "_debugCheckOwnerBuildTargetExists", + "returnType": "bool", + "signature": [ + { + "name": "methodName", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "debugGetCreatorChain", + "returnType": "String", + "signature": [ + { + "name": "limit", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a description of what caused this element to be created.\n\n Useful for debugging the source of an element.", + "annotations": [] + }, + { + "name": "debugGetDiagnosticChain", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns the parent chain from this element back to the root of the tree.\n\n Useful for debug display of a tree of Elements with only nodes in the path\n from the root to this Element expanded.", + "annotations": [] + }, + { + "name": "dispatchNotification", + "returnType": "void", + "signature": [ + { + "name": "notification", + "description": "", + "type": "Notification", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Start bubbling this notification at the given build context.\n\n The notification will be delivered to any [NotificationListener] widgets\n with the appropriate type parameters that are ancestors of the given\n [BuildContext].", + "annotations": [] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "markNeedsBuild", + "returnType": "void", + "signature": [], + "features": [], + "description": " Marks the element as dirty and adds it to the global list of widgets to\n rebuild in the next frame.\n\n Since it is inefficient to build an element twice in one frame,\n applications and widgets should be structured so as to only mark\n widgets dirty during event handlers before the frame begins, not during\n the build itself.", + "annotations": [] + }, + { + "name": "rebuild", + "returnType": "void", + "signature": [ + { + "name": "force", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Cause the widget to update itself. In debug builds, also verify various\n invariants.\n\n Called by the [BuildOwner] when [BuildOwner.scheduleBuildFor] has been\n called to mark this element dirty, by [mount] when the element is first\n built, and by [update] when the widget has changed.\n\n The method will only rebuild if [dirty] is true. To rebuild regardless\n of the [dirty] flag, set `force` to true. Forcing a rebuild is convenient\n from [update], during which [dirty] is false.\n\n ## When rebuilds happen\n\n ### Terminology\n\n [Widget]s represent the configuration of [Element]s. Each [Element] has a\n widget, specified in [Element.widget]. The term \"widget\" is often used\n when strictly speaking \"element\" would be more correct.\n\n While an [Element] has a current [Widget], over time, that widget may be\n replaced by others. For example, the element backing a [ColoredBox] may\n first have as its widget a [ColoredBox] whose [ColoredBox.color] is blue,\n then later be given a new [ColoredBox] whose color is green.\n\n At any particular time, multiple [Element]s in the same tree may have the\n same [Widget]. For example, the same [ColoredBox] with the green color may\n be used in multiple places in the widget tree at the same time, each being\n backed by a different [Element].\n\n ### Marking an element dirty\n\n An [Element] can be marked dirty between frames. This can happen for various\n reasons, including the following:\n\n * The [State] of a [StatefulWidget] can cause its [Element] to be marked\n dirty by calling the [State.setState] method.\n\n * When an [InheritedWidget] changes, descendants that have previously\n subscribed to it will be marked dirty.\n\n * During a hot reload, every element is marked dirty (using [Element.reassemble]).\n\n ### Rebuilding\n\n Dirty elements are rebuilt during the next frame. Precisely how this is\n done depends on the kind of element. A [StatelessElement] rebuilds by\n using its widget's [StatelessWidget.build] method. A [StatefulElement]\n rebuilds by using its widget's state's [State.build] method. A\n [RenderObjectElement] rebuilds by updating its [RenderObject].\n\n In many cases, the end result of rebuilding is a single child widget\n or (for [MultiChildRenderObjectElement]s) a list of children widgets.\n\n These child widgets are used to update the [widget] property of the\n element's child (or children) elements. The new [Widget] is considered to\n correspond to an existing [Element] if it has the same [Type] and [Key].\n (In the case of [MultiChildRenderObjectElement]s, some effort is put into\n tracking widgets even when they change order; see\n [RenderObjectElement.updateChildren].)\n\n If there was no corresponding previous child, this results in a new\n [Element] being created (using [Widget.createElement]); that element is\n then itself built, recursively.\n\n If there was a child previously but the build did not provide a\n corresponding child to update it, then the old child is discarded (or, in\n cases involving [GlobalKey] reparenting, reused elsewhere in the element\n tree).\n\n The most common case, however, is that there was a corresponding previous\n child. This is handled by asking the child [Element] to update itself\n using the new child [Widget]. In the case of [StatefulElement]s, this\n is what triggers [State.didUpdateWidget].\n\n ### Not rebuilding\n\n Before an [Element] is told to update itself with a new [Widget], the old\n and new objects are compared using `operator ==`.\n\n In general, this is equivalent to doing a comparison using [identical] to\n see if the two objects are in fact the exact same instance. If they are,\n and if the element is not already marked dirty for other reasons, then the\n element skips updating itself as it can determine with certainty that\n there would be no value in updating itself or its descendants.\n\n It is strongly advised to avoid overriding `operator ==` on [Widget]\n objects. While doing so seems like it could improve performance, in\n practice, for non-leaf widgets, it results in O(N²) behavior. This is\n because by necessity the comparison would have to include comparing child\n widgets, and if those child widgets also implement `operator ==`, it\n ultimately results in a complete walk of the widget tree... which is then\n repeated at each level of the tree. In practice, just rebuilding is\n cheaper. (Additionally, if _any_ subclass of [Widget] used in an\n application implements `operator ==`, then the compiler cannot inline the\n comparison anywhere, because it has to treat the call as virtual just in\n case the instance happens to be one that has an overridden operator.)\n\n Instead, the best way to avoid unnecessary rebuilds is to cache the\n widgets that are returned from [State.build], so that each frame the same\n widgets are used until such time as they change. Several mechanisms exist\n to encourage this: `const` widgets, for example, are a form of automatic\n caching (if a widget is constructed using the `const` keyword, the same\n instance is returned each time it is constructed with the same arguments).\n\n Another example is the [AnimatedBuilder.child] property, which allows the\n non-animating parts of a subtree to remain static even as the\n [AnimatedBuilder.builder] callback recreates the other components.", + "annotations": [ + "@pragma('dart2js:tryInline')", + "@pragma('vm:prefer-inline')", + "@pragma('wasm:prefer-inline')" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "MultiChildRenderObjectElement", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/input.dart", + "name": "LdInput", + "isNullSafe": true, + "description": " An input field", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "hint", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "TextEditingController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "obscureText", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "maxLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + }, + { + "name": "minLines", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autofocus", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "showClear", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "allowTapOutside", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "onBlurred", + "description": "", + "type": "dynamic Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "valid", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "loading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "autofillHints", + "description": "", + "type": "Iterable?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "textInputAction", + "description": "", + "type": "TextInputAction?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSubmitted", + "description": "", + "type": "dynamic Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "keyboardType", + "description": "", + "type": "TextInputType?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailingHint", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onCleared", + "description": "", + "type": "dynamic Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hint", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(String)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onBlurred", + "type": "dynamic Function(String)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSubmitted", + "type": "dynamic Function(String)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onCleared", + "type": "dynamic Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "controller", + "type": "TextEditingController?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autofillHints", + "type": "Iterable?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "obscureText", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autofocus", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "textInputAction", + "type": "TextInputAction?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "keyboardType", + "type": "TextInputType?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "valid", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "showClear", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loading", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowTapOutside", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailingHint", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxLines", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "minLines", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/input.dart", + "name": "_LdInputState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_focusScopeNode", + "type": "FocusScopeNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_focusNode", + "type": "FocusNode", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_createdFocusNode", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_controller", + "type": "TextEditingController", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_createdController", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdInput", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_onTextChange", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onFocusChange", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/input.dart", + "name": "LdShortcutIndicator", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "shortcut", + "description": "", + "type": "SingleActivator", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "shortcut", + "type": "SingleActivator", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/conditional_parent.dart", + "name": "LdWrapConditional", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "condition", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, Widget)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "condition", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, Widget)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/slider.dart", + "name": "LdSlider", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSlideComplete", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hint", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onSlideComplete", + "type": "void Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hint", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/slider.dart", + "name": "_LdSliderState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickers", + "type": "Set?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickerModeNotifier", + "type": "ValueListenable?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_value", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_max", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_threshold", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_sliding", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_controller", + "type": "AnimationController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_opacityController", + "type": "AnimationController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_reachedThreshold", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_thumbSize", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_thumbPadding", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdSlider", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "createTicker", + "returnType": "Ticker", + "signature": [ + { + "name": "onTick", + "description": "", + "type": "void Function(Duration)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Creates a ticker with the given callback.\n\n The kind of ticker provided depends on the kind of ticker provider.", + "annotations": [ + "@factory" + ] + }, + { + "name": "_removeTicker", + "returnType": "void", + "signature": [ + { + "name": "ticker", + "description": "", + "type": "_WidgetTicker", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickers", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickerModeNotifier", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onDragStart", + "returnType": "dynamic", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragStartDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onDragUpdate", + "returnType": "dynamic", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragUpdateDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onDragEnd", + "returnType": "dynamic", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragEndDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_activeColor", + "returnType": "Color", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_borderColor", + "returnType": "Color", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildThumb", + "returnType": "Widget", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "TickerProviderStateMixin" + ] + }, + { + "filePath": "lib/src/theme/liquid_material_theme.dart", + "name": "getMaterialTheme", + "isNullSafe": true, + "description": " build a material theme with the current [LdThemeData] to create a [MaterialApp]", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "getMaterialTheme", + "returnType": "ThemeData", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " build a material theme with the current [LdThemeData] to create a [MaterialApp]", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/theme/themed_material_app_builder.dart", + "name": "LdThemedAppBuilder", + "isNullSafe": true, + "description": " Allows you to build a styled material app\n ```dart\n LdThemedAppBuilder((context,themeData) => MaterialApp(\n theme: themeData,\n home: ....))\n ```", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "appBuilder", + "description": "", + "type": "MaterialApp Function(BuildContext, ThemeData)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "appBuilder", + "type": "MaterialApp Function(BuildContext, ThemeData)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/theme/themed_material_app_builder.dart", + "name": "_LdThemedAppBuilderState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdThemedAppBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/theme/sizing_config.dart", + "name": "LdSizingConfig", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "radiusXS", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "4.0", + "annotations": [] + }, + { + "name": "radiusS", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "8.0", + "annotations": [] + }, + { + "name": "radiusM", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "16.0", + "annotations": [] + }, + { + "name": "radiusL", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "24.0", + "annotations": [] + }, + { + "name": "themeSPaddingXS", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "4.0", + "annotations": [] + }, + { + "name": "themeSPaddingS", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "8.0", + "annotations": [] + }, + { + "name": "themeSPaddingM", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "10.0", + "annotations": [] + }, + { + "name": "themeSPaddingL", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "12.0", + "annotations": [] + }, + { + "name": "themeMPaddingXS", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "8.0", + "annotations": [] + }, + { + "name": "themeMPaddingS", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "12.0", + "annotations": [] + }, + { + "name": "themeMPaddingM", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "14.0", + "annotations": [] + }, + { + "name": "themeMPaddingL", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "24.0", + "annotations": [] + }, + { + "name": "themeLPaddingXS", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "8.0", + "annotations": [] + }, + { + "name": "themeLPaddingS", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "16.0", + "annotations": [] + }, + { + "name": "themeLPaddingM", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "24.0", + "annotations": [] + }, + { + "name": "themeLPaddingL", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "32.0", + "annotations": [] + }, + { + "name": "containerMaxWidth", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1200.0", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "radiusXS", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "radiusS", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "radiusM", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "radiusL", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeSPaddingXS", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeSPaddingS", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeSPaddingM", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeSPaddingL", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeMPaddingXS", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeMPaddingS", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeMPaddingM", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeMPaddingL", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeLPaddingXS", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeLPaddingS", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeLPaddingM", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeLPaddingL", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "containerMaxWidth", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/theme/theme_provider.dart", + "name": "LdThemeProvider", + "isNullSafe": true, + "description": " Provides a theme to all the components in the widget tree\n Theme can be accessed using LdTheme.of(context)", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "brightnessMode", + "description": "", + "type": "LdThemeBrightnessMode", + "named": true, + "required": false, + "defaultValue": "LdThemeBrightnessMode.auto", + "annotations": [] + }, + { + "name": "autoSize", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "darkPalette", + "description": "", + "type": "LdPalette?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "lightPalette", + "description": "", + "type": "LdPalette?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "screenRadiusStream", + "description": "", + "type": "Stream?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "theme", + "type": "LdTheme?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "brightnessMode", + "type": "LdThemeBrightnessMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "darkPalette", + "type": "LdPalette?", + "description": " The dark palette to use when [autoBrightness] is true defaults to [deepOcean]", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "lightPalette", + "type": "LdPalette?", + "description": " The light palette to use when [autoBrightness] is true defaults to [ocean]", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "autoSize", + "type": "bool", + "description": " If true the theme will change based on the type of the device\n will use LdThemeSize.m on mobile and LdThemeSize.s on desktop", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "screenRadiusStream", + "type": "Stream?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/theme/theme_provider.dart", + "name": "_LdThemeProviderState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_palette", + "type": "LdPalette?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_themeSize", + "type": "LdThemeSize?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_createdTheme", + "type": "LdTheme?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_screenRadiusSubscription", + "type": "StreamSubscription?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_darkPalette", + "type": "LdPalette", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_lightPalette", + "type": "LdPalette", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_theme", + "type": "LdTheme", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_windowDecoration", + "type": "BoxDecoration?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdThemeProvider", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "didPopRoute", + "returnType": "Future", + "signature": [], + "features": [], + "description": " Called when the system tells the app to pop the current route, such as\n after a system back button press or back gesture.\n\n Observers are notified in registration order until one returns\n true. If none return true, the application quits.\n\n Observers are expected to return true if they were able to\n handle the notification, for example by closing an active dialog\n box, and false otherwise. The [WidgetsApp] widget uses this\n mechanism to notify the [Navigator] widget that it should pop\n its current route if possible.\n\n This method exposes the `popRoute` notification from\n [SystemChannels.navigation].\n\n {@macro flutter.widgets.AndroidPredictiveBack}", + "annotations": [] + }, + { + "name": "handleStartBackGesture", + "returnType": "bool", + "signature": [ + { + "name": "backEvent", + "description": "", + "type": "PredictiveBackEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called at the start of a predictive back gesture.\n\n Observers are notified in registration order until one returns true or all\n observers have been notified. If an observer returns true then that\n observer, and only that observer, will be notified of subsequent events in\n this same gesture (for example [handleUpdateBackGestureProgress], etc.).\n\n Observers are expected to return true if they were able to handle the\n notification, for example by starting a predictive back animation, and\n false otherwise. [PredictiveBackPageTransitionsBuilder] uses this\n mechanism to listen for predictive back gestures.\n\n If all observers indicate they are not handling this back gesture by\n returning false, then a navigation pop will result when\n [handleCommitBackGesture] is called, as in a non-predictive system back\n gesture.\n\n Currently, this is only used on Android devices that support the\n predictive back feature.", + "annotations": [] + }, + { + "name": "handleUpdateBackGestureProgress", + "returnType": "void", + "signature": [ + { + "name": "backEvent", + "description": "", + "type": "PredictiveBackEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when a predictive back gesture moves.\n\n The observer which was notified of this gesture's [handleStartBackGesture]\n is the same observer notified for this.\n\n Currently, this is only used on Android devices that support the\n predictive back feature.", + "annotations": [] + }, + { + "name": "handleCommitBackGesture", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a predictive back gesture is finished successfully, indicating\n that the current route should be popped.\n\n The observer which was notified of this gesture's [handleStartBackGesture]\n is the same observer notified for this. If there is none, then a\n navigation pop will result, as in a non-predictive system back gesture.\n\n Currently, this is only used on Android devices that support the\n predictive back feature.", + "annotations": [] + }, + { + "name": "handleCancelBackGesture", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a predictive back gesture is canceled, indicating that no\n navigation should occur.\n\n The observer which was notified of this gesture's [handleStartBackGesture]\n is the same observer notified for this.\n\n Currently, this is only used on Android devices that support the\n predictive back feature.", + "annotations": [] + }, + { + "name": "didPushRoute", + "returnType": "Future", + "signature": [ + { + "name": "route", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when the host tells the application to push a new route onto the\n navigator.\n\n Observers are expected to return true if they were able to\n handle the notification. Observers are notified in registration\n order until one returns true.\n\n This method exposes the `pushRoute` notification from\n [SystemChannels.navigation].", + "annotations": [ + "@Deprecated('Use didPushRouteInformation instead. ' 'This feature was deprecated after v3.8.0-14.0.pre.')" + ] + }, + { + "name": "didPushRouteInformation", + "returnType": "Future", + "signature": [ + { + "name": "routeInformation", + "description": "", + "type": "RouteInformation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when the host tells the application to push a new\n [RouteInformation] and a restoration state onto the router.\n\n Observers are expected to return true if they were able to\n handle the notification. Observers are notified in registration\n order until one returns true.\n\n This method exposes the `pushRouteInformation` notification from\n [SystemChannels.navigation].\n\n The default implementation is to call the [didPushRoute] directly with the\n string constructed from [RouteInformation.uri]'s path and query parameters.", + "annotations": [] + }, + { + "name": "didChangeMetrics", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the application's dimensions change. For example,\n when a phone is rotated.\n\n This method exposes notifications from\n [dart:ui.PlatformDispatcher.onMetricsChanged].\n\n {@tool snippet}\n\n This [StatefulWidget] implements the parts of the [State] and\n [WidgetsBindingObserver] protocols necessary to react when the device is\n rotated (or otherwise changes dimensions).\n\n ```dart\n class MetricsReactor extends StatefulWidget {\n const MetricsReactor({ super.key });\n\n @override\n State createState() => _MetricsReactorState();\n }\n\n class _MetricsReactorState extends State with WidgetsBindingObserver {\n late Size _lastSize;\n\n @override\n void initState() {\n super.initState();\n WidgetsBinding.instance.addObserver(this);\n }\n\n @override\n void didChangeDependencies() {\n super.didChangeDependencies();\n // [View.of] exposes the view from `WidgetsBinding.instance.platformDispatcher.views`\n // into which this widget is drawn.\n _lastSize = View.of(context).physicalSize;\n }\n\n @override\n void dispose() {\n WidgetsBinding.instance.removeObserver(this);\n super.dispose();\n }\n\n @override\n void didChangeMetrics() {\n setState(() { _lastSize = View.of(context).physicalSize; });\n }\n\n @override\n Widget build(BuildContext context) {\n return Text('Current size: $_lastSize');\n }\n }\n ```\n {@end-tool}\n\n In general, this is unnecessary as the layout system takes care of\n automatically recomputing the application geometry when the application\n size changes.\n\n See also:\n\n * [MediaQuery.sizeOf], which provides a similar service with less\n boilerplate.", + "annotations": [] + }, + { + "name": "didChangeTextScaleFactor", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the platform's text scale factor changes.\n\n This typically happens as the result of the user changing system\n preferences, and it should affect all of the text sizes in the\n application.\n\n This method exposes notifications from\n [dart:ui.PlatformDispatcher.onTextScaleFactorChanged].\n\n {@tool snippet}\n\n ```dart\n class TextScaleFactorReactor extends StatefulWidget {\n const TextScaleFactorReactor({ super.key });\n\n @override\n State createState() => _TextScaleFactorReactorState();\n }\n\n class _TextScaleFactorReactorState extends State with WidgetsBindingObserver {\n @override\n void initState() {\n super.initState();\n WidgetsBinding.instance.addObserver(this);\n }\n\n @override\n void dispose() {\n WidgetsBinding.instance.removeObserver(this);\n super.dispose();\n }\n\n late double _lastTextScaleFactor;\n\n @override\n void didChangeTextScaleFactor() {\n setState(() { _lastTextScaleFactor = WidgetsBinding.instance.platformDispatcher.textScaleFactor; });\n }\n\n @override\n Widget build(BuildContext context) {\n return Text('Current scale factor: $_lastTextScaleFactor');\n }\n }\n ```\n {@end-tool}\n\n See also:\n\n * [MediaQuery.textScaleFactorOf], which provides a similar service with less\n boilerplate.", + "annotations": [] + }, + { + "name": "didChangePlatformBrightness", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeLocales", + "returnType": "void", + "signature": [ + { + "name": "locales", + "description": "", + "type": "List?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when the system tells the app that the user's locale has\n changed. For example, if the user changes the system language\n settings.\n\n This method exposes notifications from\n [dart:ui.PlatformDispatcher.onLocaleChanged].", + "annotations": [] + }, + { + "name": "didChangeAppLifecycleState", + "returnType": "void", + "signature": [ + { + "name": "state", + "description": "", + "type": "AppLifecycleState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when the system puts the app in the background or returns\n the app to the foreground.\n\n An example of implementing this method is provided in the class-level\n documentation for the [WidgetsBindingObserver] class.\n\n This method exposes notifications from [SystemChannels.lifecycle].\n\n See also:\n\n * [AppLifecycleListener], an alternative API for responding to\n application lifecycle changes.", + "annotations": [] + }, + { + "name": "didChangeViewFocus", + "returnType": "void", + "signature": [ + { + "name": "event", + "description": "", + "type": "ViewFocusEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the [PlatformDispatcher] receives a notification that the\n focus state on a view has changed.\n\n The [event] contains the view ID for the view that changed its focus\n state.\n\n The view ID of the [FlutterView] in which a particular [BuildContext]\n resides can be retrieved with `View.of(context).viewId`, so that it may be\n compared with the view ID in the `event` to see if the event pertains to\n the given context.", + "annotations": [] + }, + { + "name": "didRequestAppExit", + "returnType": "Future", + "signature": [], + "features": [], + "description": " Called when a request is received from the system to exit the application.\n\n If any observer responds with [AppExitResponse.cancel], it will cancel the\n exit. All observers will be asked before exiting.\n\n {@macro flutter.services.binding.ServicesBinding.requestAppExit}\n\n See also:\n\n * [ServicesBinding.exitApplication] for a function to call that will request\n that the application exits.", + "annotations": [] + }, + { + "name": "didHaveMemoryPressure", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the system is running low on memory.\n\n This method exposes the `memoryPressure` notification from\n [SystemChannels.system].", + "annotations": [] + }, + { + "name": "didChangeAccessibilityFeatures", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the system changes the set of currently active accessibility\n features.\n\n This method exposes notifications from\n [dart:ui.PlatformDispatcher.onAccessibilityFeaturesChanged].", + "annotations": [] + }, + { + "name": "_listenToScreenRadiusStream", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_applyBrightness", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "themeChanged", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "WidgetsBindingObserver" + ] + }, + { + "filePath": "lib/src/theme/theme_provider.dart", + "name": "LdThemeBrightnessMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "auto", + "type": "LdThemeBrightnessMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "light", + "type": "LdThemeBrightnessMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "dark", + "type": "LdThemeBrightnessMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/theme/theme.dart", + "name": "LdTheme", + "isNullSafe": true, + "description": " Provides a theme to all the components in the widget tree\n Theme can be accessed using LdTheme.of(context)", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_count", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_listeners", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_notificationCallStackDepth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_reentrantlyRemovedListeners", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDisposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCreationDispatched", + "type": "bool", + "description": " If true, the event [ObjectCreated] for this instance was dispatched to\n [FlutterMemoryAllocations].\n\n As [ChangeNotifier] is used as mixin, it does not have constructor,\n so we use [addListener] to dispatch the event.", + "features": [], + "annotations": [] + }, + { + "name": "hasListeners", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_palette", + "type": "LdPalette", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_defaultSize", + "type": "LdThemeSize", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_sizingConfig", + "type": "LdSizingConfig", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_platform", + "type": "LdPlatform", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_screenRadius", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_fontFamily", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_headlineFontFamily", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_fontFamilyPackage", + "type": "String?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "palette", + "type": "LdPalette", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "themeSize", + "type": "LdThemeSize", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sizingConfig", + "type": "LdSizingConfig", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "platform", + "type": "LdPlatform", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "screenRadius", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fontFamily", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "headlineFontFamily", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fontFamilyPackage", + "type": "String?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "borderWidth", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isDark", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "absolute", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "primary", + "type": "LdColor", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "secondary", + "type": "LdColor", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "success", + "type": "LdColor", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "warning", + "type": "LdColor", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "error", + "type": "LdColor", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "primaryColor", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "primaryColorText", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "secondaryColor", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "secondaryColorText", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "errorColor", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "errorColorText", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "successColor", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "successColorText", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "warningColor", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "warningColorText", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "background", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "text", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "textMuted", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "border", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "floatingBorder", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "stroke", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "surface", + "type": "Color", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "_removeAt", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Discards any resources used by the object. After this is called, the\n object is not in a usable state and should be discarded (calls to\n [addListener] will throw after the object is disposed).\n\n This method should only be called by the object's owner.\n\n This method does not notify listeners, and clears the listener list once\n it is called. Consumers of this class must decide on whether to notify\n listeners or not immediately before disposal.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "notifyListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Call this method whenever the object changes, to notify any clients the\n object may have changed. Listeners that are added during this iteration\n will not be visited. Listeners that are removed during this iteration will\n not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n This method must not be called after [dispose] has been called.\n\n Surprising behavior can result when reentrantly removing a listener (e.g.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "radius", + "returnType": "BorderRadius", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "radiusSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "setThemeSize", + "returnType": "void", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdThemeSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Set the default size for the theme", + "annotations": [] + }, + { + "name": "balPad", + "returnType": "EdgeInsets", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Get the balanced padding for a given size", + "annotations": [] + }, + { + "name": "paddingSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [], + "description": " Get the size of padding for a given size as a double", + "annotations": [] + }, + { + "name": "labelSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Get the size of a label for a given size as a double", + "annotations": [] + }, + { + "name": "paragraphSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Get the size of a paragraph for a given size as a double", + "annotations": [] + }, + { + "name": "headlineSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Get the size of a headline for a given size as a double", + "annotations": [] + }, + { + "name": "pad", + "returnType": "EdgeInsets", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [], + "description": " Get uniform padding for a given size", + "annotations": [] + }, + { + "name": "setPalette", + "returnType": "void", + "signature": [ + { + "name": "palette", + "description": "", + "type": "LdPalette", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Set the color palette for the theme", + "annotations": [] + }, + { + "name": "of", + "returnType": "LdTheme", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "listen", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Get the theme from the context. Requires a provider above the widget tree", + "annotations": [] + }, + { + "name": "neutralShade", + "returnType": "Color", + "signature": [ + { + "name": "shade", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Get a neutral shade based on the theme [shade].", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "ChangeNotifier", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/theme/theme.dart", + "name": "LdPlatform", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "macos", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "ios", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "android", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "linux", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "windows", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "webAndroid", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "webIOS", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "webMacOS", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "webWindows", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "webLinux", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "webUnknown", + "type": "LdPlatform", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/theme/theme.dart", + "name": "LdPlatformExtension", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [ + { + "name": "isDesktop", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isMobile", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isWeb", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "extension", + "aliasedType": "LdPlatform", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/theme/theme.dart", + "name": "LdThemeExtension", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [ + { + "name": "ld", + "type": "LdTheme", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "extension", + "aliasedType": "BuildContext", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/counter.dart", + "name": "_LdCounterWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "value", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "precision", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "value", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "precision", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_LdCounterWidget>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('s', defaults: {'size' : 'LdSize.s'}), Variant('l', defaults: {'size' : 'LdSize.l'}), Variant('xs', defaults: {'size' : 'LdSize.xs'})])" + ], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/counter.dart", + "name": "_LdCounterState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_digits", + "type": "List<(bool, String)>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_LdCounterWidget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_generateDigits", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/counter.dart", + "name": "_LdCounterDigit", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "digit", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "digit", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_LdCounterDigit>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/counter.dart", + "name": "_LdCounterDigitState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_textWidths", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "chars", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_LdCounterDigit", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "calculateTextWidth", + "returnType": "double", + "signature": [ + { + "name": "text", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "TextStyle", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_generateTextWidths", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/counter.dart", + "name": "LdCounter", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "precision", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "s", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "precision", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "l", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "precision", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "xs", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "precision", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "value", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "precision", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/padding.dart", + "name": "_LdPadding", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "balanced", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "sides", + "description": "", + "type": "Set<_Side>?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "sides", + "type": "Set<_Side>?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "balanced", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/padding.dart", + "name": "_Side", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "left", + "type": "_Side", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "right", + "type": "_Side", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "top", + "type": "_Side", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "bottom", + "type": "_Side", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List<_Side>", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/padding.dart", + "name": "PaddingSize", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "paddingSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "LdThemeSize", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/padding.dart", + "name": "LsPaddings", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "padXS", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padS", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padM", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padL", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "pad", + "returnType": "Widget", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padBalXs", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padBalS", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padBalM", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padBalL", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padBal", + "returnType": "Widget", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padVertical", + "returnType": "Widget", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "padHorizontal", + "returnType": "Widget", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "insetLeft", + "returnType": "Widget", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "insetRight", + "returnType": "Widget", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "insetTop", + "returnType": "Widget", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "insetBottom", + "returnType": "Widget", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "Widget", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/padding.dart", + "name": "RowSpacing", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "spaceXS", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "spaceS", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "spaceM", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "spaceL", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "Row", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/padding.dart", + "name": "WrapSpacing", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "spaceXS", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "spaceS", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "spaceM", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "spaceL", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "Wrap", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/padding.dart", + "name": "ColumnSpacing", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "spaceS", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "spaceM", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "spaceL", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "Column", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/loading_animation.dart", + "name": "LdAnimatedLoadingGradient", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "height", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "height", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_paginator.dart", + "name": "LdPaginator", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "fetchListFunction", + "description": "", + "type": "Future> Function({required int offset, required int pageSize, String? pageToken})?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "pageSize", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "10", + "annotations": [] + }, + { + "name": "autoLoad", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "initialOffset", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "debounceTime", + "description": "", + "type": "Duration", + "named": true, + "required": false, + "defaultValue": "const Duration(milliseconds: 200)", + "annotations": [] + }, + { + "name": "initialItems", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fetchQueueSize", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "3", + "annotations": [] + } + ], + "features": [], + "annotations": [] + }, + { + "name": "fromList", + "signature": [ + { + "name": "list", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "_count", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_listeners", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_notificationCallStackDepth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_reentrantlyRemovedListeners", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDisposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCreationDispatched", + "type": "bool", + "description": " If true, the event [ObjectCreated] for this instance was dispatched to\n [FlutterMemoryAllocations].\n\n As [ChangeNotifier] is used as mixin, it does not have constructor,\n so we use [addListener] to dispatch the event.", + "features": [], + "annotations": [] + }, + { + "name": "hasListeners", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fetchListFunction", + "type": "Future> Function({required int offset, required int pageSize, String? pageToken})?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "pageSize", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialOffset", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debounceTime", + "type": "Duration", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_itemsStreamController", + "type": "StreamController>>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_itemStreamController", + "type": "StreamController>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "fetchQueueSize", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_items", + "type": "Map>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_requestedOffsets", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_debounceTimer", + "type": "Timer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_mutex", + "type": "Mutex", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "totalItems", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_busy", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_error", + "type": "Object?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_currentOperation", + "type": "Completer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_offsetQueue", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_errorStackTrace", + "type": "StackTrace?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mutex", + "type": "Mutex", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "busy", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "currentItemCount", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "error", + "type": "Object?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "errorStackTrace", + "type": "StackTrace?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasError", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "items", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "itemsMap", + "type": "Map>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "itemsStream", + "type": "Stream>>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "updatedItems", + "type": "Stream>", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "_removeAt", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "notifyListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Call this method whenever the object changes, to notify any clients the\n object may have changed. Listeners that are added during this iteration\n will not be visited. Listeners that are removed during this iteration will\n not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n This method must not be called after [dispose] has been called.\n\n Surprising behavior can result when reentrantly removing a listener (e.g.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "confirmItemCreation", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newValue", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Confirm the creation of an item by index,\n index to be provided by [scheduleItemCreation]", + "annotations": [] + }, + { + "name": "confirmItemDeletion", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "refresh", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Confirms the deletion of an item.\n This will remove the item from the paginator.", + "annotations": [] + }, + { + "name": "confirmItemUpdate", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newValue", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Confirms the update of an item.\n This will apply [newValue] to the item. Otherwise the optimistic\n value previously set will be applied.", + "annotations": [] + }, + { + "name": "_triggerFetch", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fetchItemsAtOffset", + "returnType": "Future", + "signature": [ + { + "name": "offset", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fetchPageAtOffset", + "returnType": "Future", + "signature": [ + { + "name": "offset", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Fetch items at a specific offset, normalized to the nearest page size\n It makes sense to use this strategy in order to avoid fetching items\n that are already loaded.", + "annotations": [] + }, + { + "name": "getAllLoadedItems", + "returnType": "List", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getItemAt", + "returnType": "LdPaginatorItem?", + "signature": [ + { + "name": "position", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getItemById", + "returnType": "LdPaginatorItem?", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getItemIndexById", + "returnType": "int?", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isItemLoaded", + "returnType": "bool", + "signature": [ + { + "name": "position", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "refreshList", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "replaceItems", + "returnType": "void", + "signature": [ + { + "name": "items", + "description": "", + "type": "Map>", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "reset", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "rollbackItemCreation", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "rollbackItemDeletion", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Rolls back the deletion of an item.\n This will restore the item to its previous state.", + "annotations": [] + }, + { + "name": "rollbackItemUpdate", + "returnType": "Future", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newValue", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Rolls back the update of an item.x\n This will restore the item to its previous state.", + "annotations": [] + }, + { + "name": "scheduleItemCreation", + "returnType": "int", + "signature": [ + { + "name": "item", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "index", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Adds an item to the paginator at the specified index,\n or at the first available slot if no index is given.\n Returns the index of the item.", + "annotations": [] + }, + { + "name": "scheduleItemDeletion", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Schedules the deletion of an item.\n This will mark the item as being deleted. Gives the app the opportunity\n to make an api call, or show an exit animation", + "annotations": [] + }, + { + "name": "scheduleItemUpdate", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newValue", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Schedules the update of an item.\n This will mark the item as being updated. Gives the app the opportunity\n to make an api call, or show an update animation", + "annotations": [] + }, + { + "name": "setItems", + "returnType": "void", + "signature": [ + { + "name": "items", + "description": "", + "type": "List>", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "watchItem", + "returnType": "Stream>", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "watchItems", + "returnType": "Stream>", + "signature": [ + { + "name": "ids", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "watchListOfItems", + "returnType": "Stream>>", + "signature": [ + { + "name": "ids", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_fetchItems", + "returnType": "Future>", + "signature": [ + { + "name": "refresh", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_reset", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_safeExecute", + "returnType": "Future", + "signature": [ + { + "name": "operation", + "description": "", + "type": "Future Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_setBusy", + "returnType": "void", + "signature": [ + { + "name": "isBusy", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_setError", + "returnType": "void", + "signature": [ + { + "name": "error", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stackTrace", + "description": "", + "type": "StackTrace?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updated", + "returnType": "Future", + "signature": [ + { + "name": "item", + "description": "", + "type": "LdPaginatorItem?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "ChangeNotifier", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_paginator.dart", + "name": "LdPaginatorItem", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "value", + "description": "", + "type": "T?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "state", + "description": "", + "type": "LdPaginatorItemState", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "previousValue", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "value", + "type": "T?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "state", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "previousValue", + "type": "T?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "copyWith", + "returnType": "LdPaginatorItem", + "signature": [ + { + "name": "value", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "state", + "description": "", + "type": "LdPaginatorItemState?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "previousValue", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_paginator.dart", + "name": "LdPaginatorLoadedItem", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "value", + "description": "", + "type": "T?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "state", + "description": "", + "type": "LdPaginatorItemState", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "previousValue", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "value", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "state", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "previousValue", + "type": "T?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "copyWith", + "returnType": "LdPaginatorItem", + "signature": [ + { + "name": "value", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "state", + "description": "", + "type": "LdPaginatorItemState?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "previousValue", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdPaginatorItem", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_paginator.dart", + "name": "LdPaginatorItemState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "fetching", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "loaded", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "refreshing", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "updating", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "deleting", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "rolledBackDeletion", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "rolledBackUpdate", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "creating", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "rolledBackCreation", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "deleted", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "pendingRefresh", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "filteredOut", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_paginator.dart", + "name": "FetchListFunction", + "isNullSafe": true, + "description": " This function is used to fetch a range of items from a data source.\n The [offset] is the index of the first item to fetch.\n The [pageSize] is the number of items to fetch.\n The [pageToken] is a token that can be used to fetch the next page of items.", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "Future> Function({required int offset, required int pageSize, String? pageToken})", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_seperator.dart", + "name": "LdListSeperator", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSurface", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSurface", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list.dart", + "name": "_ListItem", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "type", + "description": "", + "type": "_ListItemType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "item", + "description": "", + "type": "LdPaginatorItem?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "separationCriterion", + "description": "", + "type": "dynamic", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "item", + "type": "LdPaginatorItem?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "_ListItemType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "separationCriterion", + "type": "dynamic", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "position", + "type": "int?", + "description": " The position that this item belongs to.\n Can be null for separator items.\n For regular items:\n - If item is null but position is not, the item is yet to be loaded\n - If both item and position are null, it's likely a separator", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list.dart", + "name": "LdListWidget", + "isNullSafe": true, + "description": " A sophisticated list widget that supports:\n - Pagination with loading indicators\n - Item grouping with custom separators\n - Bidirectional scrolling\n - Error handling and retry mechanisms\n - Pull-to-refresh functionality\n - Empty state handling", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "itemBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorLoadedItem, int)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "paginator", + "description": "", + "type": "LdPaginator", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "areEqual", + "description": "", + "type": "bool Function(T, T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "assumedItemHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "emptyBuilder", + "description": "", + "type": "Widget Function(BuildContext, Future Function())?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "errorBuilder", + "description": "", + "type": "Widget Function(BuildContext, Object?, void Function())?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "footer", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "groupHeaderBuilder", + "description": "", + "type": "Widget Function(BuildContext, dynamic)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "groupingCriterion", + "description": "", + "type": "dynamic Function(T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "header", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "loadingBuilder", + "description": "", + "type": "Widget Function(BuildContext, int, int)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets", + "named": true, + "required": false, + "defaultValue": "EdgeInsets.zero", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "physics", + "description": "", + "type": "ScrollPhysics?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "primary", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "retryConfig", + "description": "", + "type": "LdRetryConfig?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "scrollController", + "description": "", + "type": "ScrollController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "separatorBuilder", + "description": "", + "type": "Widget Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "shrinkWrap", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "itemBuilder", + "type": "Widget Function(BuildContext, LdPaginatorLoadedItem, int)", + "description": " Function that builds a [T] in the list.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "emptyBuilder", + "type": "Widget Function(BuildContext, Future Function())?", + "description": " Built when there are no items call [refresh] to trigger [paginator]'s refresh\n function", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorBuilder", + "type": "Widget Function(BuildContext, Object?, void Function())?", + "description": " Built when an error occurs while loading data [error] is the error that\n occurred and [retry] is a callback to retry the operation.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingBuilder", + "type": "Widget Function(BuildContext, int, int)?", + "description": " Built when there are missing items that are being loaded", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "groupingCriterion", + "type": "dynamic Function(T)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "groupHeaderBuilder", + "type": "Widget Function(BuildContext, dynamic)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "separatorBuilder", + "type": "Widget Function(BuildContext)?", + "description": " Built between items. Not called between items and group headers.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "paginator", + "type": "LdPaginator", + "description": " The paginator to use", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scrollController", + "type": "ScrollController?", + "description": " The scroll controller to use.\n If not provided, the list will use the primary scroll controller if [primary] is true.\n Otherwise, it will create a new scroll controller.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "assumedItemHeight", + "type": "double?", + "description": " The assumed height of an item. Is used to calculate the scroll space\n to virtually allocate for items that are not yet loaded.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "areEqual", + "type": "bool Function(T, T)?", + "description": " Function that checks if two items are equal.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shrinkWrap", + "type": "bool", + "description": " Whether the list should be wrapped in a shrink-wrap container.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "physics", + "type": "ScrollPhysics?", + "description": " The physics of the list.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "primary", + "type": "bool", + "description": " Whether the list is the primary scroll view of the screen.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "header", + "type": "Widget?", + "description": " A widget that is displayed at the top of the list.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "footer", + "type": "Widget?", + "description": " A widget that is displayed at the bottom of the list.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "retryConfig", + "type": "LdRetryConfig?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets", + "description": " The padding of the list.", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([])" + ], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list.dart", + "name": "_LdListState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_groupedItems", + "type": "List<_ListItem>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_scrollController", + "type": "ScrollController", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_retryController", + "type": "LdRetryController", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_itemKeys", + "type": "Map>>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_performedInitialScroll", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_scrollPhysics", + "type": "ScrollPhysics", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdListWidget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_initializeRetryController", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_setupDataListener", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_shouldRegroupItems", + "returnType": "bool", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdListWidget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_shouldUpdateDataListener", + "returnType": "bool", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdListWidget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_groupItems", + "returnType": "List<_ListItem>", + "signature": [], + "features": [], + "description": " Groups items sequentially based on the grouping criterion", + "annotations": [] + }, + { + "name": "_onDataChange", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateRetryControllerState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onRefresh", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateGroupedItems", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_createInterspersedList", + "returnType": "List<_ListItem>", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildListView", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildSlivers", + "returnType": "List", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildListItems", + "returnType": "Widget", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildListItem", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildPlaceholderItem", + "returnType": "Widget", + "signature": [ + { + "name": "position", + "description": "", + "type": "int?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildActualItem", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "listEntry", + "description": "", + "type": "_ListItem", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildEmpty", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildLoader", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Builds a loader to indicate that an item is being loaded.", + "annotations": [] + }, + { + "name": "_buildError", + "returnType": "Widget", + "signature": [ + { + "name": "error", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stackTrace", + "description": "", + "type": "StackTrace?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_getAverageItemHeight", + "returnType": "double", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_maybePerformInitialScroll", + "returnType": "Future", + "signature": [], + "features": [], + "description": " Helper method to perform the initial scroll to the correct position\n based on the initial offset.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list.dart", + "name": "LdListConfig", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "itemBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorLoadedItem, int)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "paginator", + "description": "", + "type": "LdPaginator?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "areEqual", + "description": "", + "type": "bool Function(T, T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "assumedItemHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "emptyBuilder", + "description": "", + "type": "Widget Function(BuildContext, Future Function())?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorBuilder", + "description": "", + "type": "Widget Function(BuildContext, Object?, void Function())?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "footer", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "groupHeaderBuilder", + "description": "", + "type": "Widget Function(BuildContext, dynamic)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "groupingCriterion", + "description": "", + "type": "dynamic Function(T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "header", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loadingBuilder", + "description": "", + "type": "Widget Function(BuildContext, int, int)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "physics", + "description": "", + "type": "ScrollPhysics?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "primary", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "retryConfig", + "description": "", + "type": "LdRetryConfig?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scrollController", + "description": "", + "type": "ScrollController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "separatorBuilder", + "description": "", + "type": "Widget Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "shrinkWrap", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "itemBuilder", + "type": "Widget Function(BuildContext, LdPaginatorLoadedItem, int)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "paginator", + "type": "LdPaginator?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "areEqual", + "type": "bool Function(T, T)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "assumedItemHeight", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "emptyBuilder", + "type": "Widget Function(BuildContext, Future Function())?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorBuilder", + "type": "Widget Function(BuildContext, Object?, void Function())?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "footer", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "groupHeaderBuilder", + "type": "Widget Function(BuildContext, dynamic)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "groupingCriterion", + "type": "dynamic Function(T)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "header", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingBuilder", + "type": "Widget Function(BuildContext, int, int)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "physics", + "type": "ScrollPhysics?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "primary", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "retryConfig", + "type": "LdRetryConfig?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scrollController", + "type": "ScrollController?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "separatorBuilder", + "type": "Widget Function(BuildContext)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shrinkWrap", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list.dart", + "name": "LdListConfigProvider", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdListConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "config", + "type": "LdListConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list.dart", + "name": "LdList", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "itemBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorLoadedItem, int)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "paginator", + "description": "", + "type": "LdPaginator?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "areEqual", + "description": "", + "type": "bool Function(T, T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "assumedItemHeight", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "emptyBuilder", + "description": "", + "type": "Widget Function(BuildContext, Future Function())?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "errorBuilder", + "description": "", + "type": "Widget Function(BuildContext, Object?, void Function())?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "footer", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "groupHeaderBuilder", + "description": "", + "type": "Widget Function(BuildContext, dynamic)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "groupingCriterion", + "description": "", + "type": "dynamic Function(T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "header", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loadingBuilder", + "description": "", + "type": "Widget Function(BuildContext, int, int)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "physics", + "description": "", + "type": "ScrollPhysics?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "primary", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "retryConfig", + "description": "", + "type": "LdRetryConfig?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "scrollController", + "description": "", + "type": "ScrollController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "separatorBuilder", + "description": "", + "type": "Widget Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "shrinkWrap", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "itemBuilder", + "type": "Widget Function(BuildContext, LdPaginatorLoadedItem, int)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "emptyBuilder", + "type": "Widget Function(BuildContext, Future Function())?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "errorBuilder", + "type": "Widget Function(BuildContext, Object?, void Function())?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "loadingBuilder", + "type": "Widget Function(BuildContext, int, int)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "groupingCriterion", + "type": "dynamic Function(T)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "groupHeaderBuilder", + "type": "Widget Function(BuildContext, dynamic)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "separatorBuilder", + "type": "Widget Function(BuildContext)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "paginator", + "type": "LdPaginator?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scrollController", + "type": "ScrollController?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "assumedItemHeight", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "areEqual", + "type": "bool Function(T, T)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shrinkWrap", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "physics", + "type": "ScrollPhysics?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "primary", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "header", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "footer", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "retryConfig", + "type": "LdRetryConfig?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list.dart", + "name": "_ListItemType", + "isNullSafe": true, + "description": " A model class representing an item in the list.", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "item", + "type": "_ListItemType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "separator", + "type": "_ListItemType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "groupHeader", + "type": "_ListItemType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List<_ListItemType>", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list.dart", + "name": "GetItemList", + "isNullSafe": true, + "description": " Extension to convert [LdPaginator] data into a list of [_ListItem]s", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "currentList", + "returnType": "List<_ListItem>", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "LdPaginator", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list.dart", + "name": "LdListItemBuilder", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "Widget Function(BuildContext, LdPaginatorLoadedItem, int)", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_item.dart", + "name": "LdListItemWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "isSelected", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSelectionChanged", + "description": "", + "type": "void Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "onPressed", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "selectDisabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "subContent", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "subtitle", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "tradeLeadingForSelectionControl", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [ + "@ContextConfigurable()" + ] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectionControl", + "description": "", + "type": "LdSelectionControl", + "named": true, + "required": false, + "defaultValue": "LdSelectionControl.none", + "annotations": [ + "@ContextConfigurable()" + ] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "title", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "subtitle", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "void Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectDisabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSelectionChanged", + "type": "void Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectionControl", + "type": "LdSelectionControl", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "subContent", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isSelected", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "tradeLeadingForSelectionControl", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('trailingForward', defaults: {'trailing' : 'const LdListDefaultTrailingForward()'})])" + ], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_item.dart", + "name": "LdListDefaultTrailingForward", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_item.dart", + "name": "LdListItemConfig", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isSelected", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSelectionChanged", + "description": "", + "type": "void Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectionControl", + "description": "", + "type": "LdSelectionControl?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "active", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isSelected", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSelectionChanged", + "type": "void Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "void Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectionControl", + "type": "LdSelectionControl?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_item.dart", + "name": "LdListItemConfigProvider", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdListItemConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "config", + "type": "LdListItemConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_item.dart", + "name": "LdListItem", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isSelected", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSelectionChanged", + "description": "", + "type": "void Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectDisabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "subContent", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "subtitle", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "tradeLeadingForSelectionControl", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectionControl", + "description": "", + "type": "LdSelectionControl?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "trailingForward", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isSelected", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSelectionChanged", + "description": "", + "type": "void Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectDisabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "subContent", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "subtitle", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "tradeLeadingForSelectionControl", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectionControl", + "description": "", + "type": "LdSelectionControl?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "title", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "subtitle", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "void Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectDisabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSelectionChanged", + "type": "void Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectionControl", + "type": "LdSelectionControl?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "subContent", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isSelected", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "tradeLeadingForSelectionControl", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_item.dart", + "name": "LdSelectionControl", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "none", + "type": "LdSelectionControl", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "radio", + "type": "LdSelectionControl", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "checkbox", + "type": "LdSelectionControl", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_item.dart", + "name": "OnSelectionChanged", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "void Function(bool)", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/selectable_list.dart", + "name": "LdSelectableList", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "itemBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorItem, int)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "listBuilder", + "description": "", + "type": "Widget Function(BuildContext, Widget Function(BuildContext, LdPaginatorLoadedItem, int))?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSelectionChange", + "description": "", + "type": "void Function(Set)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "multiSelect", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "paginator", + "description": "", + "type": "LdPaginator", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "showSelectionControls", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "initialSelectedItems", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "itemBuilder", + "type": "Widget Function(BuildContext, LdPaginatorItem, int)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "listBuilder", + "type": "Widget Function(BuildContext, Widget Function(BuildContext, LdPaginatorLoadedItem, int))?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialSelectedItems", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "multiSelect", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "paginator", + "type": "LdPaginator", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSelectionChange", + "type": "void Function(Set)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "showSelectionControls", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/selectable_list.dart", + "name": "_LdSelectableListState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_selectedItems", + "type": "_SetNotifier", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_dragRectItems", + "type": "_SetNotifier", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_changeNotifier", + "type": "ChangeNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_focusNode", + "type": "FocusNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_scrollController", + "type": "ScrollController", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_itemKeys", + "type": "Map>>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_itemFocusNodes", + "type": "Map", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_rootKey", + "type": "GlobalKey>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_shiftPressed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_ctrlPressed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragIsAdditive", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isDragging", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isMultiSelect", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isMobile", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdSelectableList", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "didPopRoute", + "returnType": "Future", + "signature": [], + "features": [], + "description": " Called when the system tells the app to pop the current route, such as\n after a system back button press or back gesture.\n\n Observers are notified in registration order until one returns\n true. If none return true, the application quits.\n\n Observers are expected to return true if they were able to\n handle the notification, for example by closing an active dialog\n box, and false otherwise. The [WidgetsApp] widget uses this\n mechanism to notify the [Navigator] widget that it should pop\n its current route if possible.\n\n This method exposes the `popRoute` notification from\n [SystemChannels.navigation].\n\n {@macro flutter.widgets.AndroidPredictiveBack}", + "annotations": [] + }, + { + "name": "handleStartBackGesture", + "returnType": "bool", + "signature": [ + { + "name": "backEvent", + "description": "", + "type": "PredictiveBackEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called at the start of a predictive back gesture.\n\n Observers are notified in registration order until one returns true or all\n observers have been notified. If an observer returns true then that\n observer, and only that observer, will be notified of subsequent events in\n this same gesture (for example [handleUpdateBackGestureProgress], etc.).\n\n Observers are expected to return true if they were able to handle the\n notification, for example by starting a predictive back animation, and\n false otherwise. [PredictiveBackPageTransitionsBuilder] uses this\n mechanism to listen for predictive back gestures.\n\n If all observers indicate they are not handling this back gesture by\n returning false, then a navigation pop will result when\n [handleCommitBackGesture] is called, as in a non-predictive system back\n gesture.\n\n Currently, this is only used on Android devices that support the\n predictive back feature.", + "annotations": [] + }, + { + "name": "handleUpdateBackGestureProgress", + "returnType": "void", + "signature": [ + { + "name": "backEvent", + "description": "", + "type": "PredictiveBackEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when a predictive back gesture moves.\n\n The observer which was notified of this gesture's [handleStartBackGesture]\n is the same observer notified for this.\n\n Currently, this is only used on Android devices that support the\n predictive back feature.", + "annotations": [] + }, + { + "name": "handleCommitBackGesture", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a predictive back gesture is finished successfully, indicating\n that the current route should be popped.\n\n The observer which was notified of this gesture's [handleStartBackGesture]\n is the same observer notified for this. If there is none, then a\n navigation pop will result, as in a non-predictive system back gesture.\n\n Currently, this is only used on Android devices that support the\n predictive back feature.", + "annotations": [] + }, + { + "name": "handleCancelBackGesture", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a predictive back gesture is canceled, indicating that no\n navigation should occur.\n\n The observer which was notified of this gesture's [handleStartBackGesture]\n is the same observer notified for this.\n\n Currently, this is only used on Android devices that support the\n predictive back feature.", + "annotations": [] + }, + { + "name": "didPushRoute", + "returnType": "Future", + "signature": [ + { + "name": "route", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when the host tells the application to push a new route onto the\n navigator.\n\n Observers are expected to return true if they were able to\n handle the notification. Observers are notified in registration\n order until one returns true.\n\n This method exposes the `pushRoute` notification from\n [SystemChannels.navigation].", + "annotations": [ + "@Deprecated('Use didPushRouteInformation instead. ' 'This feature was deprecated after v3.8.0-14.0.pre.')" + ] + }, + { + "name": "didPushRouteInformation", + "returnType": "Future", + "signature": [ + { + "name": "routeInformation", + "description": "", + "type": "RouteInformation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when the host tells the application to push a new\n [RouteInformation] and a restoration state onto the router.\n\n Observers are expected to return true if they were able to\n handle the notification. Observers are notified in registration\n order until one returns true.\n\n This method exposes the `pushRouteInformation` notification from\n [SystemChannels.navigation].\n\n The default implementation is to call the [didPushRoute] directly with the\n string constructed from [RouteInformation.uri]'s path and query parameters.", + "annotations": [] + }, + { + "name": "didChangeMetrics", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the application's dimensions change. For example,\n when a phone is rotated.\n\n This method exposes notifications from\n [dart:ui.PlatformDispatcher.onMetricsChanged].\n\n {@tool snippet}\n\n This [StatefulWidget] implements the parts of the [State] and\n [WidgetsBindingObserver] protocols necessary to react when the device is\n rotated (or otherwise changes dimensions).\n\n ```dart\n class MetricsReactor extends StatefulWidget {\n const MetricsReactor({ super.key });\n\n @override\n State createState() => _MetricsReactorState();\n }\n\n class _MetricsReactorState extends State with WidgetsBindingObserver {\n late Size _lastSize;\n\n @override\n void initState() {\n super.initState();\n WidgetsBinding.instance.addObserver(this);\n }\n\n @override\n void didChangeDependencies() {\n super.didChangeDependencies();\n // [View.of] exposes the view from `WidgetsBinding.instance.platformDispatcher.views`\n // into which this widget is drawn.\n _lastSize = View.of(context).physicalSize;\n }\n\n @override\n void dispose() {\n WidgetsBinding.instance.removeObserver(this);\n super.dispose();\n }\n\n @override\n void didChangeMetrics() {\n setState(() { _lastSize = View.of(context).physicalSize; });\n }\n\n @override\n Widget build(BuildContext context) {\n return Text('Current size: $_lastSize');\n }\n }\n ```\n {@end-tool}\n\n In general, this is unnecessary as the layout system takes care of\n automatically recomputing the application geometry when the application\n size changes.\n\n See also:\n\n * [MediaQuery.sizeOf], which provides a similar service with less\n boilerplate.", + "annotations": [] + }, + { + "name": "didChangeTextScaleFactor", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the platform's text scale factor changes.\n\n This typically happens as the result of the user changing system\n preferences, and it should affect all of the text sizes in the\n application.\n\n This method exposes notifications from\n [dart:ui.PlatformDispatcher.onTextScaleFactorChanged].\n\n {@tool snippet}\n\n ```dart\n class TextScaleFactorReactor extends StatefulWidget {\n const TextScaleFactorReactor({ super.key });\n\n @override\n State createState() => _TextScaleFactorReactorState();\n }\n\n class _TextScaleFactorReactorState extends State with WidgetsBindingObserver {\n @override\n void initState() {\n super.initState();\n WidgetsBinding.instance.addObserver(this);\n }\n\n @override\n void dispose() {\n WidgetsBinding.instance.removeObserver(this);\n super.dispose();\n }\n\n late double _lastTextScaleFactor;\n\n @override\n void didChangeTextScaleFactor() {\n setState(() { _lastTextScaleFactor = WidgetsBinding.instance.platformDispatcher.textScaleFactor; });\n }\n\n @override\n Widget build(BuildContext context) {\n return Text('Current scale factor: $_lastTextScaleFactor');\n }\n }\n ```\n {@end-tool}\n\n See also:\n\n * [MediaQuery.textScaleFactorOf], which provides a similar service with less\n boilerplate.", + "annotations": [] + }, + { + "name": "didChangePlatformBrightness", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the platform brightness changes.\n\n This method exposes notifications from\n [dart:ui.PlatformDispatcher.onPlatformBrightnessChanged].\n\n See also:\n\n * [MediaQuery.platformBrightnessOf], which provides a similar service with\n less boilerplate.", + "annotations": [] + }, + { + "name": "didChangeLocales", + "returnType": "void", + "signature": [ + { + "name": "locales", + "description": "", + "type": "List?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when the system tells the app that the user's locale has\n changed. For example, if the user changes the system language\n settings.\n\n This method exposes notifications from\n [dart:ui.PlatformDispatcher.onLocaleChanged].", + "annotations": [] + }, + { + "name": "didChangeAppLifecycleState", + "returnType": "void", + "signature": [ + { + "name": "state", + "description": "", + "type": "AppLifecycleState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeViewFocus", + "returnType": "void", + "signature": [ + { + "name": "event", + "description": "", + "type": "ViewFocusEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the [PlatformDispatcher] receives a notification that the\n focus state on a view has changed.\n\n The [event] contains the view ID for the view that changed its focus\n state.\n\n The view ID of the [FlutterView] in which a particular [BuildContext]\n resides can be retrieved with `View.of(context).viewId`, so that it may be\n compared with the view ID in the `event` to see if the event pertains to\n the given context.", + "annotations": [] + }, + { + "name": "didRequestAppExit", + "returnType": "Future", + "signature": [], + "features": [], + "description": " Called when a request is received from the system to exit the application.\n\n If any observer responds with [AppExitResponse.cancel], it will cancel the\n exit. All observers will be asked before exiting.\n\n {@macro flutter.services.binding.ServicesBinding.requestAppExit}\n\n See also:\n\n * [ServicesBinding.exitApplication] for a function to call that will request\n that the application exits.", + "annotations": [] + }, + { + "name": "didHaveMemoryPressure", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the system is running low on memory.\n\n This method exposes the `memoryPressure` notification from\n [SystemChannels.system].", + "annotations": [] + }, + { + "name": "didChangeAccessibilityFeatures", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the system changes the set of currently active accessibility\n features.\n\n This method exposes notifications from\n [dart:ui.PlatformDispatcher.onAccessibilityFeaturesChanged].", + "annotations": [] + }, + { + "name": "isSelected", + "returnType": "bool", + "signature": [ + { + "name": "item", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "onTap", + "returnType": "void", + "signature": [ + { + "name": "item", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_selectRange", + "returnType": "void", + "signature": [ + { + "name": "end", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "onSelectionChange", + "returnType": "void", + "signature": [ + { + "name": "item", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selected", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onUpdateDragRect", + "returnType": "void", + "signature": [ + { + "name": "dragRect", + "description": "", + "type": "Rect", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "directionIsDownRight", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onEndDrag", + "returnType": "Future", + "signature": [ + { + "name": "rect", + "description": "", + "type": "Rect", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onCancel", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onFocusChange", + "returnType": "void", + "signature": [ + { + "name": "hasFocus", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onKeyEvent", + "returnType": "KeyEventResult", + "signature": [ + { + "name": "node", + "description": "", + "type": "FocusNode", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "event", + "description": "", + "type": "KeyEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_defaultListBuilder", + "returnType": "LdList", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "itemBuilder", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorLoadedItem, int)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_wrapListItem", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "item", + "description": "", + "type": "LdPaginatorItem", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "WidgetsBindingObserver" + ] + }, + { + "filePath": "lib/src/list/selectable_list.dart", + "name": "_SetNotifier", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "value", + "description": "", + "type": "Set?", + "named": false, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowMultiple", + "description": "", + "type": "bool", + "named": false, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_value", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "value", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_count", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_listeners", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_notificationCallStackDepth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_reentrantlyRemovedListeners", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDisposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCreationDispatched", + "type": "bool", + "description": " If true, the event [ObjectCreated] for this instance was dispatched to\n [FlutterMemoryAllocations].\n\n As [ChangeNotifier] is used as mixin, it does not have constructor,\n so we use [addListener] to dispatch the event.", + "features": [], + "annotations": [] + }, + { + "name": "hasListeners", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "allowMultiple", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "_removeAt", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Discards any resources used by the object. After this is called, the\n object is not in a usable state and should be discarded (calls to\n [addListener] will throw after the object is disposed).\n\n This method should only be called by the object's owner.\n\n This method does not notify listeners, and clears the listener list once\n it is called. Consumers of this class must decide on whether to notify\n listeners or not immediately before disposal.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "notifyListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Call this method whenever the object changes, to notify any clients the\n object may have changed. Listeners that are added during this iteration\n will not be visited. Listeners that are removed during this iteration will\n not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n This method must not be called after [dispose] has been called.\n\n Surprising behavior can result when reentrantly removing a listener (e.g.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "setValue", + "returnType": "void", + "signature": [ + { + "name": "value", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "add", + "returnType": "void", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toggle", + "returnType": "void", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "remove", + "returnType": "void", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "clear", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "addAll", + "returnType": "void", + "signature": [ + { + "name": "items", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "removeAll", + "returnType": "void", + "signature": [ + { + "name": "items", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "contains", + "returnType": "bool", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "ValueNotifier", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/selectable_list.dart", + "name": "_DragRect", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "onTapOutside", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onUpdateRect", + "description": "", + "type": "void Function(Rect, bool)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onEndDrag", + "description": "", + "type": "void Function(Rect)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mobile", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onCancel", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isAdditive", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onUpdateRect", + "type": "void Function(Rect, bool)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onEndDrag", + "type": "void Function(Rect)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onCancel", + "type": "void Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onTapOutside", + "type": "void Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isAdditive", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mobile", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_DragRect>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/selectable_list.dart", + "name": "_DragRectState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragStartOffset", + "type": "Offset?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragEndOffset", + "type": "Offset?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_overlayPortalController", + "type": "OverlayPortalController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_dragRect", + "type": "Rect?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is inserted into the tree.\n\n The framework will call this method exactly once for each [State] object\n it creates.\n\n Override this method to perform initialization that depends on the\n location at which this object was inserted into the tree (i.e., [context])\n or on the widget used to configure this object (i.e., [widget]).\n\n {@template flutter.widgets.State.initState}\n If a [State]'s [build] method depends on an object that can itself\n change state, for example a [ChangeNotifier] or [Stream], or some\n other object to which one can subscribe to receive notifications, then\n be sure to subscribe and unsubscribe properly in [initState],\n [didUpdateWidget], and [dispose]:\n\n * In [initState], subscribe to the object.\n * In [didUpdateWidget] unsubscribe from the old object and subscribe\n to the new one if the updated widget configuration requires\n replacing the object.\n * In [dispose], unsubscribe from the object.\n\n {@endtemplate}\n\n You should not use [BuildContext.dependOnInheritedWidgetOfExactType] from this\n method. However, [didChangeDependencies] will be called immediately\n following this method, and [BuildContext.dependOnInheritedWidgetOfExactType] can\n be used there.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.initState()`.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_DragRect", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree permanently.\n\n The framework calls this method when this [State] object will never\n build again. After the framework calls [dispose], the [State] object is\n considered unmounted and the [mounted] property is false. It is an error\n to call [setState] at this point. This stage of the lifecycle is terminal:\n there is no way to remount a [State] object that has been disposed.\n\n Subclasses should override this method to release any resources retained\n by this object (e.g., stop any active animations).\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.dispose()`.\n\n ## Caveats\n\n This method is _not_ invoked at times where a developer might otherwise\n expect it, such as application shutdown or dismissal via platform\n native methods.\n\n ### Application shutdown\n\n There is no way to predict when application shutdown will happen. For\n example, a user's battery could catch fire, or the user could drop the\n device into a swimming pool, or the operating system could unilaterally\n terminate the application process due to memory pressure.\n\n Applications are responsible for ensuring that they are well-behaved\n even in the face of a rapid unscheduled termination.\n\n To artificially cause the entire widget tree to be disposed, consider\n calling [runApp] with a widget such as [SizedBox.shrink].\n\n To listen for platform shutdown messages (and other lifecycle changes),\n consider the [AppLifecycleListener] API.\n\n {@macro flutter.widgets.runApp.dismissal}\n\n See the method used to bootstrap the app (e.g. [runApp] or [runWidget])\n for suggestions on how to release resources more eagerly.\n\n See also:\n\n * [deactivate], which is called prior to [dispose].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_buildMobileGestureDetector", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildDesktopGestureDetector", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildDesktopDragRect", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "rect", + "description": "", + "type": "Rect", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildDragRect", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "rect", + "description": "", + "type": "Rect", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_page.dart", + "name": "LdListPage", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "newItems", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hasMore", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "total", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "nextPageToken", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + }, + { + "name": "fromList", + "signature": [ + { + "name": "items", + "description": "", + "type": "List", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "pageSize", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "10", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "newItems", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hasMore", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "total", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "nextPageToken", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "copyWith", + "returnType": "LdListPage", + "signature": [ + { + "name": "newItems", + "description": "", + "type": "List?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hasMore", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "total", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "nextPageToken", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/ld_list_item_animation.dart", + "name": "LdListItemAnimation", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "state", + "description": "", + "type": "LdPaginatorItemState", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "state", + "type": "LdPaginatorItemState", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_item_toggle.dart", + "name": "LdListItemToggle", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "subtitle", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "checked", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "void Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "title", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "subtitle", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "checked", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onChanged", + "type": "void Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_loading.dart", + "name": "LdListItemLoading", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hasLeading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "hasTrailing", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "hasSubContent", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "hasSubtitle", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasLeading", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hasTrailing", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hasSubContent", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hasSubtitle", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/list_empty.dart", + "name": "LdListEmpty", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onRefresh", + "description": "", + "type": "Function?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "text", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onRefresh", + "type": "Function?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "text", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/list/table_row.dart", + "name": "LdTableRow", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "active", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "isSelected", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSelectionChanged", + "description": "", + "type": "void Function(bool)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onPressed", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "padding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectDisabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "subContent", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "subtitle", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "focusNode", + "description": "", + "type": "FocusNode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "trailing", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "width", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectionControl", + "description": "", + "type": "LdSelectionControl", + "named": true, + "required": false, + "defaultValue": "LdSelectionControl.none", + "annotations": [] + }, + { + "name": "isOdd", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "trailing", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "padding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "title", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "active", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "subtitle", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPressed", + "type": "void Function()?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectDisabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onSelectionChanged", + "type": "void Function(bool)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectionControl", + "type": "LdSelectionControl", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "subContent", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isSelected", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "focusNode", + "type": "FocusNode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isOdd", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/drawer_layout.dart", + "name": "LdDrawerLayout", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "drawer", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "body", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "reflowBreakpoint", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "drawerWidth", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "enableScaling", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "onStateChange", + "description": "", + "type": "void Function(LdDrawerState)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "drawer", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "body", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "reflowBreakpoint", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "enableScaling", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onStateChange", + "type": "void Function(LdDrawerState)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "drawerWidth", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "maybeStateOf", + "returnType": "LdDrawerLayoutState?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "openDrawer", + "returnType": "dynamic", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "closeDrawer", + "returnType": "dynamic", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "toggleDrawer", + "returnType": "dynamic", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/drawer_layout.dart", + "name": "LdDrawerLayoutState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_historyEntry", + "type": "LocalHistoryEntry?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_visibleStartIndex", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_visibleEndIndex", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_effectiveDrawerWidth", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isSideBySide", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isDrawerOpen", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_drawerBorder", + "type": "Border?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdDrawerLayout", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "openDrawer", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "closeDrawer", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toggleDrawer", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onVisibleRangeChanged", + "returnType": "void", + "signature": [ + { + "name": "startIndex", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "endIndex", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_ensureHistoryEntry", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onStateChange", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_handleHistoryEntryRemoved", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_showDrawer", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_hideDrawer", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/window_frame.dart", + "name": "LdWindowFrame", + "isNullSafe": true, + "description": " Show a frame around the window that has a surface color. Only is shown on\n Windows, Linux, and MacOS.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "frameBuilder", + "description": "", + "type": "Widget Function(BuildContext, Widget)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "frameBuilder", + "type": "Widget Function(BuildContext, Widget)", + "description": " The frameBuilder can be used to wrap the child in a frame. This is useful\n for wrapping it in a [MoveWindow] widget.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "title", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "showWindowFrame", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/indicators.dart", + "name": "_LdIndicatorWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "type", + "type": "LdIndicatorType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "customSize", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [ + "@Variants([Variant('info', defaults: {'type' : 'LdIndicatorType.info'}), Variant('warning', defaults: {'type' : 'LdIndicatorType.warning'}), Variant('canceled', defaults: {'type' : 'LdIndicatorType.canceled'}), Variant('error', defaults: {'type' : 'LdIndicatorType.error'}), Variant('success', defaults: {'type' : 'LdIndicatorType.success'}), Variant('loading', defaults: {'type' : 'LdIndicatorType.loading'}), Variant('pending', defaults: {'type' : 'LdIndicatorType.pending'}), Variant('ongoing', defaults: {'type' : 'LdIndicatorType.ongoing'})])" + ], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/indicators.dart", + "name": "LdIndicator", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "info", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "warning", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "canceled", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "error", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "success", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "loading", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "pending", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "ongoing", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdIndicatorType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "customSize", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "type", + "type": "LdIndicatorType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "customSize", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/indicators.dart", + "name": "LdIndicatorType", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "info", + "type": "LdIndicatorType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "warning", + "type": "LdIndicatorType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "canceled", + "type": "LdIndicatorType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "error", + "type": "LdIndicatorType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "success", + "type": "LdIndicatorType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "loading", + "type": "LdIndicatorType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "pending", + "type": "LdIndicatorType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "ongoing", + "type": "LdIndicatorType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold_layout_state.dart", + "name": "LdScaffoldAppBarState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "innerHeight", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "verticalMargin", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "effectiveHeight", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "effectiveInnerHeight", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "effectivePosition", + "description": "", + "type": "EffectivePosition", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "innerHeight", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "verticalMargin", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "effectiveHeight", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "effectiveInnerHeight", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "effectivePosition", + "type": "EffectivePosition", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold_layout_state.dart", + "name": "LdScaffoldLayoutState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "slot", + "description": "", + "type": "LdScaffoldSlot", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "bodyScrollOffset", + "description": "", + "type": "ValueNotifier", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "drawerScrollOffset", + "description": "", + "type": "ValueNotifier", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "appBarOffset", + "description": "", + "type": "ValueNotifier", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAppBarOffset", + "description": "", + "type": "ValueNotifier", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "parentLayoutState", + "description": "", + "type": "LdScaffoldLayoutState?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isScrolled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "appBarState", + "description": "", + "type": "LdScaffoldAppBarState?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAppBarState", + "description": "", + "type": "LdScaffoldAppBarState?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "bodyScrollOffset", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "drawerScrollOffset", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "appBarOffset", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "secondaryAppBarOffset", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "slot", + "type": "LdScaffoldSlot", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "parentLayoutState", + "type": "LdScaffoldLayoutState?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugName", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isScrolled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "appBarState", + "type": "LdScaffoldAppBarState?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "secondaryAppBarState", + "type": "LdScaffoldAppBarState?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "level", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "totalInsets", + "type": "EdgeInsets", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "toDebugString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "levelForEffectivePosition", + "returnType": "int", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "effectiveHeightOfOthers", + "returnType": "double", + "signature": [ + { + "name": "effectivePosition", + "description": "", + "type": "EffectivePosition", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "appBarRole", + "description": "", + "type": "AppBarRole", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "copyWith", + "returnType": "LdScaffoldLayoutState", + "signature": [ + { + "name": "bodyScrollOffset", + "description": "", + "type": "ValueNotifier?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "drawerScrollOffset", + "description": "", + "type": "ValueNotifier?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "appBarOffset", + "description": "", + "type": "ValueNotifier?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAppBarOffset", + "description": "", + "type": "ValueNotifier?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "slot", + "description": "", + "type": "LdScaffoldSlot?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "parentLayoutState", + "description": "", + "type": "LdScaffoldLayoutState?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "appBarState", + "description": "", + "type": "LdScaffoldAppBarState?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAppBarState", + "description": "", + "type": "LdScaffoldAppBarState?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isScrolled", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold_layout_state.dart", + "name": "LdScaffoldSlot", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "body", + "type": "LdScaffoldSlot", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "drawer", + "type": "LdScaffoldSlot", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold_layout_state.dart", + "name": "EffectivePosition", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "top", + "type": "EffectivePosition", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "bottom", + "type": "EffectivePosition", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold_layout_state.dart", + "name": "AppBarRole", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "primary", + "type": "AppBarRole", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "secondary", + "type": "AppBarRole", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/scaffold_layout_state.dart", + "name": "LdScaffoldSlotExtension", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [ + { + "name": "effectivePosition", + "type": "EffectivePosition", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "role", + "type": "AppBarRole", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "extension", + "aliasedType": "LdScaffoldSlot", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/typography.dart", + "name": "LdMute", + "isNullSafe": true, + "description": " LdMute allows you to use the LdTheme to make a muted text", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/typography.dart", + "name": "LdThemeSize", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "s", + "type": "LdThemeSize", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "m", + "type": "LdThemeSize", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "l", + "type": "LdThemeSize", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/typography.dart", + "name": "FontSize", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "labelSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "paragraphSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "headlineSize", + "returnType": "double", + "signature": [ + { + "name": "size", + "description": "", + "type": "LdSize", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "LdThemeSize", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/form_label.dart", + "name": "LdFormLabel", + "isNullSafe": true, + "description": " A label for a form field. This is a convenience widget that wraps a [Text]\n and [ldSpacerS]. THIS WIDGET contains outer padding.!", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "direction", + "description": "", + "type": "Axis", + "named": true, + "required": false, + "defaultValue": "Axis.vertical", + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "direction", + "type": "Axis", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/divider.dart", + "name": "LdDivider", + "isNullSafe": true, + "description": " Divides some content with a horizontal", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "height", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "insetForLeading", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "height", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "insetForLeading", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_effective_layout_mode.dart", + "name": "LdMonkeyEffectiveLayoutMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "master", + "type": "LdMonkeyEffectiveLayoutMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "detail", + "type": "LdMonkeyEffectiveLayoutMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "sideBySide", + "type": "LdMonkeyEffectiveLayoutMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/intents.dart", + "name": "SearchIntent", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [], + "methods": [ + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Intent", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/intents.dart", + "name": "SearchAction", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "searchFocusNode", + "description": "", + "type": "FocusNode", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_listeners", + "type": "ObserverList)>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_currentCallingAction", + "type": "Action?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "callingAction", + "type": "Action?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "intentType", + "type": "Type", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isActionEnabled", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "searchFocusNode", + "type": "FocusNode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_updateCallingAction", + "returnType": "void", + "signature": [ + { + "name": "value", + "description": "", + "type": "Action?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isEnabled", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "SearchIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns true if the action is enabled and is ready to be invoked.\n\n This will be called by the [ActionDispatcher] before attempting to invoke\n the action.\n\n If the action's enable state depends on a [BuildContext], subclass\n [ContextAction] instead of [Action].", + "annotations": [] + }, + { + "name": "_isEnabled", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "SearchIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "consumesKey", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "SearchIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Indicates whether this action should treat key events mapped to this\n action as being \"handled\" when it is invoked via the key event.\n\n If the key is handled, then no other key event handlers in the focus chain\n will receive the event.\n\n If the key event is not handled, it will be passed back to the engine, and\n continue to be processed there, allowing text fields and non-Flutter\n widgets to receive the key event.\n\n The default implementation returns true.", + "annotations": [] + }, + { + "name": "toKeyEventResult", + "returnType": "KeyEventResult", + "signature": [ + { + "name": "intent", + "description": "", + "type": "SearchIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "invokeResult", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Converts the result of [invoke] of this action to a [KeyEventResult].\n\n This is typically used when the action is invoked in response to a keyboard\n shortcut.\n\n The [invokeResult] argument is the value returned by the [invoke] method.\n\n By default, calls [consumesKey] and converts the returned boolean to\n [KeyEventResult.handled] if it's true, and [KeyEventResult.skipRemainingHandlers]\n if it's false.\n\n Concrete implementations may refine the type of [invokeResult], since\n they know the type returned by [invoke].", + "annotations": [] + }, + { + "name": "invoke", + "returnType": "void", + "signature": [ + { + "name": "intent", + "description": "", + "type": "SearchIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_invoke", + "returnType": "Object?", + "signature": [ + { + "name": "intent", + "description": "", + "type": "SearchIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "addActionListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function(Action)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Register a callback to listen for changes to the state of this action.\n\n If you call this, you must call [removeActionListener] a matching number\n of times, or memory leaks will occur. To help manage this and avoid memory\n leaks, use of the [ActionListener] widget to register and unregister your\n listener appropriately is highly recommended.\n\n {@template flutter.widgets.Action.addActionListener}\n If a listener had been added twice, and is removed once during an\n iteration (i.e. in response to a notification), it will still be called\n again. If, on the other hand, it is removed as many times as it was\n registered, then it will no longer be called. This odd behavior is the\n result of the [Action] not being able to determine which listener\n is being removed, since they are identical, and therefore conservatively\n still calling all the listeners when it knows that any are still\n registered.\n\n This surprising behavior can be unexpectedly observed when registering a\n listener on two separate objects which are both forwarding all\n registrations to a common upstream object.\n {@endtemplate}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "removeActionListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function(Action)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove a previously registered closure from the list of closures that are\n notified when the object changes.\n\n If the given listener is not registered, the call is ignored.\n\n If you call [addActionListener], you must call this method a matching\n number of times, or memory leaks will occur. To help manage this and avoid\n memory leaks, use of the [ActionListener] widget to register and\n unregister your listener appropriately is highly recommended.\n\n {@macro flutter.widgets.Action.addActionListener}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "notifyActionListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Subclasses should call this method whenever the object changes, to notify\n any clients the object may have changed. Listeners that are added during this\n iteration will not be visited. Listeners that are removed during this\n iteration will not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n Surprising behavior can result when reentrantly removing a listener (i.e.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeActionListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "_makeOverridableAction", + "returnType": "Action", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Action", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/intents.dart", + "name": "RefreshIntent", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [], + "methods": [ + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Intent", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/intents.dart", + "name": "SelectAllIntent", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [], + "methods": [ + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Intent", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/intents.dart", + "name": "OpenDrawerIntent", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [], + "methods": [ + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Intent", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/intents.dart", + "name": "CloseDrawerIntent", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [], + "methods": [ + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Intent", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/intents.dart", + "name": "ToggleDrawerIntent", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [], + "methods": [ + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Intent", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/sort/sort_option.dart", + "name": "LdSortOption", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticSort", + "description": "", + "type": "int Function(T, T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "name", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "label", + "type": "String Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "optimisticSort", + "type": "int Function(T, T)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isOn", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "name", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "serialize", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "copyWith", + "returnType": "LdSortOption", + "signature": [ + { + "name": "isOn", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_shell_state.dart", + "name": "LdMonkeyShellState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "basePath", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_count", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_listeners", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_notificationCallStackDepth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_reentrantlyRemovedListeners", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDisposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCreationDispatched", + "type": "bool", + "description": " If true, the event [ObjectCreated] for this instance was dispatched to\n [FlutterMemoryAllocations].\n\n As [ChangeNotifier] is used as mixin, it does not have constructor,\n so we use [addListener] to dispatch the event.", + "features": [], + "annotations": [] + }, + { + "name": "hasListeners", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_immediateViewSelection", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_allowMultipleSelection", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "basePath", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_selectedItems", + "type": "Set", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_selectedItemsStreamController", + "type": "StreamController>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_viewingItems", + "type": "Set", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_viewingItemsStreamController", + "type": "StreamController>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_showSelectionControls", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_effectiveLayout", + "type": "LdMonkeyEffectiveLayoutMode?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectedItemsStream", + "type": "Stream>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "viewingItemsStream", + "type": "Stream>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "selectedItems", + "type": "Set", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "viewingItems", + "type": "Set", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showSelectionControls", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "immediateViewSelection", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "allowMultipleSelection", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "effectiveLayout", + "type": "LdMonkeyEffectiveLayoutMode?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "_removeAt", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Discards any resources used by the object. After this is called, the\n object is not in a usable state and should be discarded (calls to\n [addListener] will throw after the object is disposed).\n\n This method should only be called by the object's owner.\n\n This method does not notify listeners, and clears the listener list once\n it is called. Consumers of this class must decide on whether to notify\n listeners or not immediately before disposal.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "notifyListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Call this method whenever the object changes, to notify any clients the\n object may have changed. Listeners that are added during this iteration\n will not be visited. Listeners that are removed during this iteration will\n not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n This method must not be called after [dispose] has been called.\n\n Surprising behavior can result when reentrantly removing a listener (e.g.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "setSelectedItems", + "returnType": "void", + "signature": [ + { + "name": "selectedItems", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "setImmediateViewSelection", + "returnType": "void", + "signature": [ + { + "name": "immediateViewSelection", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "setAllowMultipleSelection", + "returnType": "void", + "signature": [ + { + "name": "allowMultipleSelection", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "setViewingItems", + "returnType": "void", + "signature": [ + { + "name": "viewingItems", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "setShowSelectionControls", + "returnType": "void", + "signature": [ + { + "name": "showSelectionControls", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "setEffectiveLayout", + "returnType": "void", + "signature": [ + { + "name": "effectiveLayout", + "description": "", + "type": "LdMonkeyEffectiveLayoutMode", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "of", + "returnType": "LdMonkeyShellState", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "watch", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "maybeOf", + "returnType": "LdMonkeyShellState?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "listen", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [ + "ChangeNotifier" + ] + }, + { + "filePath": "lib/src/monkey/monkey_selection.dart", + "name": "LdMonkeySelection", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "selection", + "description": "", + "type": "Set", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "viewing", + "description": "", + "type": "Set", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "selection", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "viewing", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "of", + "returnType": "LdMonkeySelection", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "listen", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "adaptive", + "returnType": "Set", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "listen", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "location", + "description": "", + "type": "LdMonkeyActionLocation?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "getSelectedItems", + "returnType": "Future>", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "getViewingItems", + "returnType": "Future>", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_app_bar.dart", + "name": "LdMonkeyAppBar", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "additionalActions", + "description": "", + "type": "List", + "named": true, + "required": false, + "defaultValue": "const []", + "annotations": [] + }, + { + "name": "positionMode", + "description": "", + "type": "LdAppBarPositionMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "location", + "description": "", + "type": "LdMonkeyActionLocation", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "leading", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugName", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "backgroundMode", + "description": "", + "type": "LdAppBarBackgroundMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "shadowMode", + "description": "", + "type": "LdAppBarShadowMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "borderMode", + "description": "", + "type": "LdAppBarBorderMode?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "title", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "location", + "type": "LdMonkeyActionLocation", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugName", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "additionalActions", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "leading", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "positionMode", + "type": "LdAppBarPositionMode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "backgroundMode", + "type": "LdAppBarBackgroundMode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shadowMode", + "type": "LdAppBarShadowMode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderMode", + "type": "LdAppBarBorderMode?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_getSearchFilter", + "returnType": "LdFilterSearch?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_shell.dart", + "name": "LdMonkeyShell", + "isNullSafe": true, + "description": " The shell route that is wrapped around the master and detail pages.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "basePath", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "layoutMode", + "description": "", + "type": "LdMonkeyLayoutMode", + "named": true, + "required": false, + "defaultValue": "LdMonkeyLayoutMode.auto", + "annotations": [] + }, + { + "name": "routeState", + "description": "", + "type": "GoRouterState", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "masterPage", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "parseSelected", + "description": "", + "type": "Set Function(String)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "actions", + "description": "", + "type": "List>", + "named": true, + "required": false, + "defaultValue": "const []", + "annotations": [] + }, + { + "name": "buildDetailPath", + "description": "", + "type": "String Function(Set)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "detailPanelFlex", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": "2", + "annotations": [] + }, + { + "name": "reflowBreakpoint", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "600", + "annotations": [] + }, + { + "name": "repositoryBuilder", + "description": "", + "type": "Future> Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "pathParameterName", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "immediateViewSelection", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "allowMultipleSelection", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "pathParameterName", + "type": "String", + "description": " The item id for the route parameters, this will be used to disambiguate between multiple monkey patterns", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "routeState", + "type": "GoRouterState", + "description": " The state of the route parameters, this will be used to get the selected items", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "basePath", + "type": "String", + "description": " The base path for the monkey pattern.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": " Child route provided by navigator", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowMultipleSelection", + "type": "bool", + "description": " Whether multiple selection is allowed.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "repositoryBuilder", + "type": "Future> Function(BuildContext)?", + "description": " Builder function that creates a repository instance asynchronously.\n If not provided, the repository will be looked up in the context.\n If the repository is not found in the context, an exception is thrown.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "parseSelected", + "type": "Set Function(String)", + "description": " Function to parse selected items in URL to [IdType].\n\n Used when converting URL parameters back to typed IDs for selection\n and navigation purposes. The default is to parse the selected items\n as a comma separated list of ids.\n If the id type is [int], the ids are parsed as integers.\n If the id type is [String], the ids are parsed as strings.\n If the id type is not supported, an exception is thrown.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "layoutMode", + "type": "LdMonkeyLayoutMode", + "description": " Controls the layout behavior of the master-detail interface.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "actions", + "type": "List>", + "description": " The actions that are available in the master and detail pages.\n", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "reflowBreakpoint", + "type": "double", + "description": " Breakpoint width in pixels for responsive layout switching.\n\n When the screen width is above this value and [layoutMode] is [LdMonkeyLayoutMode.auto],\n the component will display in side-by-side mode. Defaults to 600 pixels.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "detailPanelFlex", + "type": "int?", + "description": " Flex ratio for the detail panel in side-by-side layout.\n\n Higher values give more space to the detail view. Defaults to 2.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "buildDetailPath", + "type": "String Function(Set)?", + "description": " Function to generate the detail path for a set of selected item IDs.\n\n This determines how selected items are represented in the URL path.\n For single selection, typically returns `/path/{id}`, for multiple\n selection, typically returns `/path/{id1,id2,id3}`.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "masterPage", + "type": "Widget", + "description": " The master page to display in the master panel. This parameter is not used\n if the the effective layout is not side by side.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "immediateViewSelection", + "type": "bool", + "description": " When true, selection immediately updates viewing and URL (old behavior).\n When false, selection and viewing are decoupled when selection controls\n are enabled or multiple items are selected.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "routeSelection", + "type": "String?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "queryParameters", + "type": "Map", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_shell.dart", + "name": "_LdMonkeyShellState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_repository", + "type": "LdRepository?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_filterSubscription", + "type": "StreamSubscription", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_sortSubscription", + "type": "StreamSubscription", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_repositoryUpdatedItemsSubscription", + "type": "StreamSubscription", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_state", + "type": "LdMonkeyShellState", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_urlUpdateMutex", + "type": "Completer?", + "description": " Mutex to prevent race condition between state→URL and URL→state updates.\n When applying state to URL, we create a completer. URL changes that try\n to update state will check if this completer exists and skip the update\n if it does (meaning we're currently applying state to URL).", + "features": [], + "annotations": [] + }, + { + "name": "_lastEffectiveLayout", + "type": "LdMonkeyEffectiveLayoutMode?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "actions", + "type": "List>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "state", + "type": "LdMonkeyShellState", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_showingDetail", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdMonkeyShell", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_initRepository", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_parseSelected", + "returnType": "Set", + "signature": [ + { + "name": "selected", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onStateChange", + "returnType": "void", + "signature": [], + "features": [], + "description": " Callback when state changes - applies state to URL.", + "annotations": [] + }, + { + "name": "_onUrlChange", + "returnType": "void", + "signature": [], + "features": [], + "description": " Callback when URL changes - applies URL to state.", + "annotations": [] + }, + { + "name": "_setupSubscriptions", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "setShowSelectionControls", + "returnType": "void", + "signature": [ + { + "name": "showSelectionControls", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Sets the visibility of selection controls and updates the URL.", + "annotations": [] + }, + { + "name": "showSelection", + "returnType": "Future", + "signature": [], + "features": [], + "description": " Moves selection to viewing items, making the selected items visible in the detail view.", + "annotations": [] + }, + { + "name": "_buildQueryParameters", + "returnType": "Map", + "signature": [], + "features": [], + "description": " Builds query parameters from repository and state.", + "annotations": [] + }, + { + "name": "_geteEffectiveLayoutMode", + "returnType": "LdMonkeyEffectiveLayoutMode", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_serialiseDetailPath", + "returnType": "String", + "signature": [ + { + "name": "ids", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_applyStateToUrl", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildInitialized", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_shell.dart", + "name": "LdMonkeyActions", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "List>", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_layout_mode.dart", + "name": "LdMonkeyLayoutMode", + "isNullSafe": true, + "description": " Defines the layout behavior of the master-detail interface.", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "auto", + "type": "LdMonkeyLayoutMode", + "description": " Automatically switch between side-by-side and stacked layouts based on screen size.", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "sideBySide", + "type": "LdMonkeyLayoutMode", + "description": " Always display in side-by-side layout regardless of screen size.", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "neverSideBySide", + "type": "LdMonkeyLayoutMode", + "description": " Always display in stacked layout regardless of screen size.", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/actions.dart", + "name": "LdMonkeyAction", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "visibility", + "description": "", + "type": "Set", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "multiSelect", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "shortcutActivators", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "visibility", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "multiSelect", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shortcutActivators", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "onShortcutPressed", + "returnType": "Future", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": "", + "annotations": [] + }, + { + "name": "isVisible", + "returnType": "bool", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "location", + "description": "", + "type": "LdMonkeyActionLocation?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/actions.dart", + "name": "LdMonkeyBareChildAction", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "visibility", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + }, + { + "name": "multiSelect", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "shortcutActivators", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + }, + { + "name": "onShortcutTrigger", + "description": "", + "type": "FutureOr Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "visibility", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "multiSelect", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shortcutActivators", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onShortcutTrigger", + "type": "FutureOr Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "onShortcutPressed", + "returnType": "Future", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "isVisible", + "returnType": "bool", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "location", + "description": "", + "type": "LdMonkeyActionLocation?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdMonkeyAction", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/actions.dart", + "name": "LdMonkeySubmitAction", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "config", + "description": "", + "type": "LdSubmitConfig Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "visibility", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + }, + { + "name": "multiSelect", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "shortcutActivators", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "LdSubmitBuilder?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "visibility", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "multiSelect", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "shortcutActivators", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "config", + "type": "LdSubmitConfig Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "LdSubmitBuilder?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "controller", + "type": "LdSubmitController?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "onShortcutPressed", + "returnType": "Future", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "isVisible", + "returnType": "bool", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "location", + "description": "", + "type": "LdMonkeyActionLocation?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdMonkeyAction", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/actions.dart", + "name": "OpenDrawerAction", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "onOpenDrawer", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_listeners", + "type": "ObserverList)>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_currentCallingAction", + "type": "Action?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "callingAction", + "type": "Action?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "intentType", + "type": "Type", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isActionEnabled", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onOpenDrawer", + "type": "void Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_updateCallingAction", + "returnType": "void", + "signature": [ + { + "name": "value", + "description": "", + "type": "Action?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isEnabled", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "OpenDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns true if the action is enabled and is ready to be invoked.\n\n This will be called by the [ActionDispatcher] before attempting to invoke\n the action.\n\n If the action's enable state depends on a [BuildContext], subclass\n [ContextAction] instead of [Action].", + "annotations": [] + }, + { + "name": "_isEnabled", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "OpenDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "consumesKey", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "OpenDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Indicates whether this action should treat key events mapped to this\n action as being \"handled\" when it is invoked via the key event.\n\n If the key is handled, then no other key event handlers in the focus chain\n will receive the event.\n\n If the key event is not handled, it will be passed back to the engine, and\n continue to be processed there, allowing text fields and non-Flutter\n widgets to receive the key event.\n\n The default implementation returns true.", + "annotations": [] + }, + { + "name": "toKeyEventResult", + "returnType": "KeyEventResult", + "signature": [ + { + "name": "intent", + "description": "", + "type": "OpenDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "invokeResult", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Converts the result of [invoke] of this action to a [KeyEventResult].\n\n This is typically used when the action is invoked in response to a keyboard\n shortcut.\n\n The [invokeResult] argument is the value returned by the [invoke] method.\n\n By default, calls [consumesKey] and converts the returned boolean to\n [KeyEventResult.handled] if it's true, and [KeyEventResult.skipRemainingHandlers]\n if it's false.\n\n Concrete implementations may refine the type of [invokeResult], since\n they know the type returned by [invoke].", + "annotations": [] + }, + { + "name": "invoke", + "returnType": "void", + "signature": [ + { + "name": "intent", + "description": "", + "type": "OpenDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_invoke", + "returnType": "Object?", + "signature": [ + { + "name": "intent", + "description": "", + "type": "OpenDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "addActionListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function(Action)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Register a callback to listen for changes to the state of this action.\n\n If you call this, you must call [removeActionListener] a matching number\n of times, or memory leaks will occur. To help manage this and avoid memory\n leaks, use of the [ActionListener] widget to register and unregister your\n listener appropriately is highly recommended.\n\n {@template flutter.widgets.Action.addActionListener}\n If a listener had been added twice, and is removed once during an\n iteration (i.e. in response to a notification), it will still be called\n again. If, on the other hand, it is removed as many times as it was\n registered, then it will no longer be called. This odd behavior is the\n result of the [Action] not being able to determine which listener\n is being removed, since they are identical, and therefore conservatively\n still calling all the listeners when it knows that any are still\n registered.\n\n This surprising behavior can be unexpectedly observed when registering a\n listener on two separate objects which are both forwarding all\n registrations to a common upstream object.\n {@endtemplate}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "removeActionListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function(Action)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove a previously registered closure from the list of closures that are\n notified when the object changes.\n\n If the given listener is not registered, the call is ignored.\n\n If you call [addActionListener], you must call this method a matching\n number of times, or memory leaks will occur. To help manage this and avoid\n memory leaks, use of the [ActionListener] widget to register and\n unregister your listener appropriately is highly recommended.\n\n {@macro flutter.widgets.Action.addActionListener}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "notifyActionListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Subclasses should call this method whenever the object changes, to notify\n any clients the object may have changed. Listeners that are added during this\n iteration will not be visited. Listeners that are removed during this\n iteration will not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n Surprising behavior can result when reentrantly removing a listener (i.e.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeActionListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "_makeOverridableAction", + "returnType": "Action", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Action", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/actions.dart", + "name": "CloseDrawerAction", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "onCloseDrawer", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_listeners", + "type": "ObserverList)>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_currentCallingAction", + "type": "Action?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "callingAction", + "type": "Action?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "intentType", + "type": "Type", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isActionEnabled", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onCloseDrawer", + "type": "void Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_updateCallingAction", + "returnType": "void", + "signature": [ + { + "name": "value", + "description": "", + "type": "Action?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isEnabled", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "CloseDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns true if the action is enabled and is ready to be invoked.\n\n This will be called by the [ActionDispatcher] before attempting to invoke\n the action.\n\n If the action's enable state depends on a [BuildContext], subclass\n [ContextAction] instead of [Action].", + "annotations": [] + }, + { + "name": "_isEnabled", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "CloseDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "consumesKey", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "CloseDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Indicates whether this action should treat key events mapped to this\n action as being \"handled\" when it is invoked via the key event.\n\n If the key is handled, then no other key event handlers in the focus chain\n will receive the event.\n\n If the key event is not handled, it will be passed back to the engine, and\n continue to be processed there, allowing text fields and non-Flutter\n widgets to receive the key event.\n\n The default implementation returns true.", + "annotations": [] + }, + { + "name": "toKeyEventResult", + "returnType": "KeyEventResult", + "signature": [ + { + "name": "intent", + "description": "", + "type": "CloseDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "invokeResult", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Converts the result of [invoke] of this action to a [KeyEventResult].\n\n This is typically used when the action is invoked in response to a keyboard\n shortcut.\n\n The [invokeResult] argument is the value returned by the [invoke] method.\n\n By default, calls [consumesKey] and converts the returned boolean to\n [KeyEventResult.handled] if it's true, and [KeyEventResult.skipRemainingHandlers]\n if it's false.\n\n Concrete implementations may refine the type of [invokeResult], since\n they know the type returned by [invoke].", + "annotations": [] + }, + { + "name": "invoke", + "returnType": "void", + "signature": [ + { + "name": "intent", + "description": "", + "type": "CloseDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_invoke", + "returnType": "Object?", + "signature": [ + { + "name": "intent", + "description": "", + "type": "CloseDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "addActionListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function(Action)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Register a callback to listen for changes to the state of this action.\n\n If you call this, you must call [removeActionListener] a matching number\n of times, or memory leaks will occur. To help manage this and avoid memory\n leaks, use of the [ActionListener] widget to register and unregister your\n listener appropriately is highly recommended.\n\n {@template flutter.widgets.Action.addActionListener}\n If a listener had been added twice, and is removed once during an\n iteration (i.e. in response to a notification), it will still be called\n again. If, on the other hand, it is removed as many times as it was\n registered, then it will no longer be called. This odd behavior is the\n result of the [Action] not being able to determine which listener\n is being removed, since they are identical, and therefore conservatively\n still calling all the listeners when it knows that any are still\n registered.\n\n This surprising behavior can be unexpectedly observed when registering a\n listener on two separate objects which are both forwarding all\n registrations to a common upstream object.\n {@endtemplate}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "removeActionListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function(Action)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove a previously registered closure from the list of closures that are\n notified when the object changes.\n\n If the given listener is not registered, the call is ignored.\n\n If you call [addActionListener], you must call this method a matching\n number of times, or memory leaks will occur. To help manage this and avoid\n memory leaks, use of the [ActionListener] widget to register and\n unregister your listener appropriately is highly recommended.\n\n {@macro flutter.widgets.Action.addActionListener}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "notifyActionListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Subclasses should call this method whenever the object changes, to notify\n any clients the object may have changed. Listeners that are added during this\n iteration will not be visited. Listeners that are removed during this\n iteration will not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n Surprising behavior can result when reentrantly removing a listener (i.e.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeActionListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "_makeOverridableAction", + "returnType": "Action", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Action", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/actions.dart", + "name": "ToggleDrawerAction", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "onToggleDrawer", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isActionEnabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_listeners", + "type": "ObserverList)>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_currentCallingAction", + "type": "Action?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "callingAction", + "type": "Action?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "intentType", + "type": "Type", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isActionEnabled", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onToggleDrawer", + "type": "void Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_isActionEnabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_updateCallingAction", + "returnType": "void", + "signature": [ + { + "name": "value", + "description": "", + "type": "Action?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isEnabled", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "ToggleDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns true if the action is enabled and is ready to be invoked.\n\n This will be called by the [ActionDispatcher] before attempting to invoke\n the action.\n\n If the action's enable state depends on a [BuildContext], subclass\n [ContextAction] instead of [Action].", + "annotations": [] + }, + { + "name": "_isEnabled", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "ToggleDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "consumesKey", + "returnType": "bool", + "signature": [ + { + "name": "intent", + "description": "", + "type": "ToggleDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Indicates whether this action should treat key events mapped to this\n action as being \"handled\" when it is invoked via the key event.\n\n If the key is handled, then no other key event handlers in the focus chain\n will receive the event.\n\n If the key event is not handled, it will be passed back to the engine, and\n continue to be processed there, allowing text fields and non-Flutter\n widgets to receive the key event.\n\n The default implementation returns true.", + "annotations": [] + }, + { + "name": "toKeyEventResult", + "returnType": "KeyEventResult", + "signature": [ + { + "name": "intent", + "description": "", + "type": "ToggleDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "invokeResult", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Converts the result of [invoke] of this action to a [KeyEventResult].\n\n This is typically used when the action is invoked in response to a keyboard\n shortcut.\n\n The [invokeResult] argument is the value returned by the [invoke] method.\n\n By default, calls [consumesKey] and converts the returned boolean to\n [KeyEventResult.handled] if it's true, and [KeyEventResult.skipRemainingHandlers]\n if it's false.\n\n Concrete implementations may refine the type of [invokeResult], since\n they know the type returned by [invoke].", + "annotations": [] + }, + { + "name": "invoke", + "returnType": "void", + "signature": [ + { + "name": "intent", + "description": "", + "type": "ToggleDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_invoke", + "returnType": "Object?", + "signature": [ + { + "name": "intent", + "description": "", + "type": "ToggleDrawerIntent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "addActionListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function(Action)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Register a callback to listen for changes to the state of this action.\n\n If you call this, you must call [removeActionListener] a matching number\n of times, or memory leaks will occur. To help manage this and avoid memory\n leaks, use of the [ActionListener] widget to register and unregister your\n listener appropriately is highly recommended.\n\n {@template flutter.widgets.Action.addActionListener}\n If a listener had been added twice, and is removed once during an\n iteration (i.e. in response to a notification), it will still be called\n again. If, on the other hand, it is removed as many times as it was\n registered, then it will no longer be called. This odd behavior is the\n result of the [Action] not being able to determine which listener\n is being removed, since they are identical, and therefore conservatively\n still calling all the listeners when it knows that any are still\n registered.\n\n This surprising behavior can be unexpectedly observed when registering a\n listener on two separate objects which are both forwarding all\n registrations to a common upstream object.\n {@endtemplate}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "removeActionListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function(Action)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove a previously registered closure from the list of closures that are\n notified when the object changes.\n\n If the given listener is not registered, the call is ignored.\n\n If you call [addActionListener], you must call this method a matching\n number of times, or memory leaks will occur. To help manage this and avoid\n memory leaks, use of the [ActionListener] widget to register and\n unregister your listener appropriately is highly recommended.\n\n {@macro flutter.widgets.Action.addActionListener}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "notifyActionListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Subclasses should call this method whenever the object changes, to notify\n any clients the object may have changed. Listeners that are added during this\n iteration will not be visited. Listeners that are removed during this\n iteration will not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n Surprising behavior can result when reentrantly removing a listener (i.e.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeActionListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "_makeOverridableAction", + "returnType": "Action", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Action", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/actions.dart", + "name": "LdMonkeyActionLocation", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "masterAppBar", + "type": "LdMonkeyActionLocation", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "masterSecondary", + "type": "LdMonkeyActionLocation", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "detailAppBar", + "type": "LdMonkeyActionLocation", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "detailSecondary", + "type": "LdMonkeyActionLocation", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "context", + "type": "LdMonkeyActionLocation", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/toggle_filter_action.dart", + "name": "showFilterContextMenu", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "showFilterContextMenu", + "returnType": "LdMonkeyAction", + "signature": [], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/toggle_filter_action.dart", + "name": "showFilterModal", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "showFilterModal", + "returnType": "LdMonkeyAction", + "signature": [], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/action_visibility.dart", + "name": "LdMonkeyActionVisibility", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "location", + "description": "", + "type": "LdMonkeyActionLocation", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minSelectionCount", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "maxSelectionCount", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "applyFilters", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + }, + { + "name": "layoutModes", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {LdMonkeyEffectiveLayoutMode.master, LdMonkeyEffectiveLayoutMode.detail, LdMonkeyEffectiveLayoutMode.sideBySide}", + "annotations": [] + }, + { + "name": "visibleWhenShowingSelectionControls", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "location", + "type": "LdMonkeyActionLocation", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "minSelectionCount", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "maxSelectionCount", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "visibleWhenShowingSelectionControls", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "layoutModes", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "applyFilters", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/keyboard_shortcuts.dart", + "name": "LdMonkeyMultiShortcuts", + "isNullSafe": true, + "description": " The shortcuts for multiple items. Will only apply the shortcuts if the user\n is currently selecting multiple items.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "actions", + "description": "", + "type": "List>", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "actions", + "type": "List>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/keyboard_shortcuts.dart", + "name": "LdMonkeySingleShortcuts", + "isNullSafe": true, + "description": " The shortcuts for a single item. Will only apply the shortcuts if the user\n is currently not selecting multiple items.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "actions", + "description": "", + "type": "List>", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "item", + "description": "", + "type": "IdType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "actions", + "type": "List>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "item", + "type": "IdType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/show_selection_action.dart", + "name": "showSelection", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "showSelection", + "returnType": "LdMonkeyAction", + "signature": [], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/context_menu.dart", + "name": "LdMonkeyContextMenu", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "item", + "description": "", + "type": "LdPaginatorItem", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "item", + "type": "LdPaginatorItem", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/app_bar_actions.dart", + "name": "ldMonkeyAppBarActionsForLocation", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ldMonkeyAppBarActionsForLocation", + "returnType": "List>", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "location", + "description": "", + "type": "LdMonkeyActionLocation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/actions/toggle_selection_controls_action.dart", + "name": "toggleSelectionControls", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "toggleSelectionControls", + "returnType": "LdMonkeyAction", + "signature": [], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_bool.dart", + "name": "LdFilterBool", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "label", + "type": "String Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "name", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isOn", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_optimisticFilter", + "type": "bool Function(T)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "serialize", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "marshalSerialized", + "returnType": "LdFilterBool", + "signature": [ + { + "name": "value", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "optimisticFilter", + "returnType": "bool", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "copyWith", + "returnType": "LdFilterBool", + "signature": [ + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "repository", + "description": "", + "type": "LdRepository", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdFilterOption", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_any_of_widget.dart", + "name": "LdFilterAnyOfWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "filter", + "description": "", + "type": "LdFilterAnyOf", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "filter", + "type": "LdFilterAnyOf", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_search.dart", + "name": "LdFilterSearch", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "searchText", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "hint", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T, String)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "getSuggestions", + "description": "", + "type": "Future> Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildSuggestion", + "description": "", + "type": "LdListItem Function(BuildContext, dynamic)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debounceDelay", + "description": "", + "type": "Duration", + "named": true, + "required": false, + "defaultValue": "const Duration(milliseconds: 300)", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "label", + "type": "String Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "name", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isOn", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "searchText", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_optimisticFilter", + "type": "bool Function(T, String)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "getSuggestions", + "type": "Future> Function(String)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "buildSuggestion", + "type": "LdListItem Function(BuildContext, dynamic)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debounceDelay", + "type": "Duration", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hint", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "serialize", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "marshalSerialized", + "returnType": "LdFilterSearch", + "signature": [ + { + "name": "value", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "optimisticFilter", + "returnType": "bool", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "copyWith", + "returnType": "LdFilterSearch", + "signature": [ + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "searchText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "hint", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T, String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "getSuggestions", + "description": "", + "type": "Future> Function(String)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildSuggestion", + "description": "", + "type": "LdListItem Function(BuildContext, dynamic)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debounceDelay", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "repository", + "description": "", + "type": "LdRepository", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "searchConfig", + "returnType": "LdSearchConfig", + "signature": [ + { + "name": "onSearch", + "description": "", + "type": "dynamic Function(String)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdFilterOption", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_any_of.dart", + "name": "LdFilterAnyOf", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "allValues", + "description": "", + "type": "Map", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialSelected", + "description": "", + "type": "Set?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T, List)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "label", + "type": "String Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "name", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isOn", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allValues", + "type": "Map", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectedValues", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_optimisticFilter", + "type": "bool Function(T, List)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "serialize", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "marshalSerialized", + "returnType": "LdFilterAnyOf", + "signature": [ + { + "name": "value", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "optimisticFilter", + "returnType": "bool", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "copyWith", + "returnType": "LdFilterAnyOf", + "signature": [ + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allValues", + "description": "", + "type": "Map?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectedValues", + "description": "", + "type": "Set?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T, List)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "repository", + "description": "", + "type": "LdRepository", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdFilterOption", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_range.dart", + "name": "LdFilterRange", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "min", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "step", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "1", + "annotations": [] + }, + { + "name": "max", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T, RangeValues)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "range", + "description": "", + "type": "RangeValues?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "label", + "type": "String Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "name", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isOn", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "range", + "type": "RangeValues", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "min", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "max", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "step", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_optimisticFilter", + "type": "bool Function(T, RangeValues)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "serialize", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "marshalSerialized", + "returnType": "LdFilterRange", + "signature": [ + { + "name": "value", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "optimisticFilter", + "returnType": "bool", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "copyWith", + "returnType": "LdFilterRange", + "signature": [ + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "range", + "description": "", + "type": "RangeValues?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "min", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "max", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "step", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T, RangeValues)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "repository", + "description": "", + "type": "LdRepository", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdFilterOption", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_range.dart", + "name": "LdFilterRangeWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "filter", + "description": "", + "type": "LdFilterRange", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "filter", + "type": "LdFilterRange", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_range.dart", + "name": "InRange", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "inRange", + "returnType": "bool", + "signature": [ + { + "name": "value", + "description": "", + "type": "num", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "extension", + "aliasedType": "RangeValues", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_one_of.dart", + "name": "LdFilterOneOf", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "allValues", + "description": "", + "type": "Map", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialSelected", + "description": "", + "type": "E?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T, E?)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "label", + "type": "String Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "name", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isOn", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allValues", + "type": "Map", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "selectedValue", + "type": "E?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_optimisticFilter", + "type": "bool Function(T, E?)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "serialize", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "marshalSerialized", + "returnType": "LdFilterOneOf", + "signature": [ + { + "name": "value", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "optimisticFilter", + "returnType": "bool", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "copyWith", + "returnType": "LdFilterOneOf", + "signature": [ + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allValues", + "description": "", + "type": "Map?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "selectedValue", + "description": "", + "type": "E?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "optimisticFilter", + "description": "", + "type": "bool Function(T, E?)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "repository", + "description": "", + "type": "LdRepository", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdFilterOption", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_option.dart", + "name": "LdFilterOption", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "name", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "label", + "type": "String Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "icon", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "name", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isOn", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "serialize", + "returnType": "String", + "signature": [], + "features": [ + "abstract" + ], + "description": "", + "annotations": [] + }, + { + "name": "marshalSerialized", + "returnType": "LdFilterOption", + "signature": [ + { + "name": "entry", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": "", + "annotations": [] + }, + { + "name": "optimisticFilter", + "returnType": "bool", + "signature": [ + { + "name": "item", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Returns true if the item should be included in the list, is called\n before the list is re-fetched", + "annotations": [] + }, + { + "name": "copyWith", + "returnType": "LdFilterOption", + "signature": [ + { + "name": "label", + "description": "", + "type": "String Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "icon", + "description": "", + "type": "Widget Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isOn", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Create a copy of this filter option with the given fields replaced", + "annotations": [] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "repository", + "description": "", + "type": "LdRepository", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/ld_filter_one_of_widget.dart", + "name": "LdFilterOneOfWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "filter", + "description": "", + "type": "LdFilterOneOf", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "filter", + "type": "LdFilterOneOf", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/filter_modal.dart", + "name": "LdFilterContextMenu", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/filter_modal.dart", + "name": "LdFilterModal", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/filter_modal.dart", + "name": "_Filter", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "filter", + "description": "", + "type": "LdFilterOption", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "filter", + "type": "LdFilterOption", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/filter/filter_modal.dart", + "name": "ldFilterModal", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ldFilterModal", + "returnType": "LdModalRoute", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_routes.dart", + "name": "buildMonkeyRoutes", + "isNullSafe": true, + "description": " Builds the routing configuration for a monkey component.\n\n Creates a set of [GoRoute] instances that handle:\n - Master list view at the base [basePath]\n - Detail view at [basePath]/:selected_[pathParameterName]\n - Filter modal at [basePath]/filters\n\n The routes are wrapped in a [ShellRoute] that provides the master-detail\n layout and handles responsive behavior.\n\n ## Parameters\n\n - [basePath]: The base route path for the master view\n - [pathParameterName]: The name of the path parameter for the selected items\n - [repositoryBuilder]: Builder function that creates a repository instance asynchronously\n - [layoutMode]: Controls the layout behavior of the master-detail interface\n - [shellBuilder]: Optional wrapper widget that can be used to wrap the entire monkey shell\n - [masterPageBuilder]: Optional builder for the master page (defaults to [LdMonkeyMasterPage])\n - [detailPageBuilder]: Optional builder for the detail page (defaults to [LdMonkeyDetailPage])\n - [filterModalBuilder]: Optional builder for the filter modal (defaults to [ldFilterModal])\n\n Returns a list of routes that can be added to a [GoRouter] configuration.", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "buildMonkeyRoutes", + "returnType": "List", + "signature": [ + { + "name": "basePath", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "detailPage", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "masterPage", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "repositoryBuilder", + "description": "", + "type": "Future> Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "layoutMode", + "description": "", + "type": "LdMonkeyLayoutMode", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "parseSelected", + "description": "", + "type": "Set Function(String)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "pathParameterName", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "shellBuilder", + "description": "", + "type": "Widget Function({required String basePath, required Widget child, required BuildContext context, required Widget masterPage, required String pathParameterName, required GoRouterState routeState})?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "filterModalBuilder", + "description": "", + "type": "LdModalRoute Function(BuildContext)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "detailInDialog", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Builds the routing configuration for a monkey component.\n\n Creates a set of [GoRoute] instances that handle:\n - Master list view at the base [basePath]\n - Detail view at [basePath]/:selected_[pathParameterName]\n - Filter modal at [basePath]/filters\n\n The routes are wrapped in a [ShellRoute] that provides the master-detail\n layout and handles responsive behavior.\n\n ## Parameters\n\n - [basePath]: The base route path for the master view\n - [pathParameterName]: The name of the path parameter for the selected items\n - [repositoryBuilder]: Builder function that creates a repository instance asynchronously\n - [layoutMode]: Controls the layout behavior of the master-detail interface\n - [shellBuilder]: Optional wrapper widget that can be used to wrap the entire monkey shell\n - [masterPageBuilder]: Optional builder for the master page (defaults to [LdMonkeyMasterPage])\n - [detailPageBuilder]: Optional builder for the detail page (defaults to [LdMonkeyDetailPage])\n - [filterModalBuilder]: Optional builder for the filter modal (defaults to [ldFilterModal])\n\n Returns a list of routes that can be added to a [GoRouter] configuration.", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/detail_page.dart", + "name": "LdMonkeyDetailPage", + "isNullSafe": true, + "description": " The page rendered by [LdMonkey] to show the detail of the selected\n items", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "primaryAppBar", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAppBar", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "body", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "scrollable", + "signature": [ + { + "name": "primaryAppBar", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAppBar", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildDetail", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorItem)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "stacked", + "signature": [ + { + "name": "primaryAppBar", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAppBar", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildDetail", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorItem)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "primaryAppBar", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "secondaryAppBar", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "body", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/detail_page.dart", + "name": "LdMonkeyStreamSelection", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, List>)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, List>)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/detail_page.dart", + "name": "_LdMonkeyStreamSelectionState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_viewingSubscription", + "type": "StreamSubscription>", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_itemsSubscription", + "type": "StreamSubscription>>?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_items", + "type": "List>", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdMonkeyStreamSelection", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_onSelectionChanged", + "returnType": "void", + "signature": [ + { + "name": "viewing", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onItemsChanged", + "returnType": "void", + "signature": [ + { + "name": "items", + "description": "", + "type": "List>", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_master_page.dart", + "name": "LdMonkeyMasterPage", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildItem", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorItem)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "appBar", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAppBar", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildList", + "description": "", + "type": "Widget Function(BuildContext, LdRepository)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "buildList", + "type": "Widget Function(BuildContext, LdRepository)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "buildItem", + "type": "Widget Function(BuildContext, LdPaginatorItem)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "appBar", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "secondaryAppBar", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_master_page.dart", + "name": "_LdMonkeyMasterPageState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "searchConfig", + "type": "LdSearchConfig?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdMonkeyMasterPage", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_buildList", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "repository", + "description": "", + "type": "LdRepository", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "shellState", + "description": "", + "type": "LdMonkeyShellState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "actions", + "description": "", + "type": "List>", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/data/identifiable.dart", + "name": "Identifiable", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [ + { + "name": "id", + "type": "I", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "idString", + "type": "String", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "mixin", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/data/repository.dart", + "name": "LdRepository", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "fetchListWithParameters", + "description": "", + "type": "Future> Function({Set>? filters, required int offset, required int pageSize, String? pageToken, List>? sortOptions})", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "pageSize", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "10", + "annotations": [] + }, + { + "name": "getById", + "description": "", + "type": "Future Function(IdType)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "filters", + "description": "", + "type": "Set>?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "sortOptions", + "description": "", + "type": "List>?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "getOffsetById", + "description": "", + "type": "Future Function(IdType, {Set>? filters, List>? sortOptions})?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "deleteItem", + "description": "", + "type": "Future Function(IdType)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "updateItem", + "description": "", + "type": "Future Function(IdType, T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "createItem", + "description": "", + "type": "Future Function(T?)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "deleteBatch", + "description": "", + "type": "Future Function(Set)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "updateBatch", + "description": "", + "type": "Future Function(Set)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "singularItemTitle", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "\"Item\"", + "annotations": [] + }, + { + "name": "pluralItemTitle", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "\"Items\"", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "fetchListFunction", + "type": "Future> Function({required int offset, required int pageSize, String? pageToken})?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "pageSize", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialOffset", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debounceTime", + "type": "Duration", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_itemsStreamController", + "type": "StreamController>>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_itemStreamController", + "type": "StreamController>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "fetchQueueSize", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_items", + "type": "Map>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_requestedOffsets", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_debounceTimer", + "type": "Timer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_mutex", + "type": "Mutex", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "totalItems", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_busy", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_error", + "type": "Object?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_currentOperation", + "type": "Completer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_offsetQueue", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_errorStackTrace", + "type": "StackTrace?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mutex", + "type": "Mutex", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "busy", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "currentItemCount", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "error", + "type": "Object?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "errorStackTrace", + "type": "StackTrace?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasError", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "items", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "itemsMap", + "type": "Map>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "itemsStream", + "type": "Stream>>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "updatedItems", + "type": "Stream>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_count", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_listeners", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_notificationCallStackDepth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_reentrantlyRemovedListeners", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDisposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCreationDispatched", + "type": "bool", + "description": " If true, the event [ObjectCreated] for this instance was dispatched to\n [FlutterMemoryAllocations].\n\n As [ChangeNotifier] is used as mixin, it does not have constructor,\n so we use [addListener] to dispatch the event.", + "features": [], + "annotations": [] + }, + { + "name": "hasListeners", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_getById", + "type": "Future Function(IdType)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_getOffsetById", + "type": "Future Function(IdType, {Set>? filters, List>? sortOptions})?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_updateBatch", + "type": "Future Function(Set)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_deleteItem", + "type": "Future Function(IdType)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_updateItem", + "type": "Future Function(IdType, T)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_createItem", + "type": "Future Function(T?)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_deleteBatch", + "type": "Future Function(Set)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_fetchListWithParameters", + "type": "Future> Function({Set>? filters, required int offset, required int pageSize, String? pageToken, List>? sortOptions})", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "singularItemTitle", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "pluralItemTitle", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_filters", + "type": "Map>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_sortOptions", + "type": "List>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_filterStreamController", + "type": "StreamController>>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_sortStreamController", + "type": "StreamController>>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "filters", + "type": "Map>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sortOptions", + "type": "List>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "filterStream", + "type": "Stream>>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sortStream", + "type": "Stream>>", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "queryParameters", + "type": "Map", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "activeFilters", + "type": "Iterable>", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "confirmItemCreation", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newValue", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Confirm the creation of an item by index,\n index to be provided by [scheduleItemCreation]", + "annotations": [] + }, + { + "name": "confirmItemDeletion", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "refresh", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Confirms the deletion of an item.\n This will remove the item from the paginator.", + "annotations": [] + }, + { + "name": "confirmItemUpdate", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newValue", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Confirms the update of an item.\n This will apply [newValue] to the item. Otherwise the optimistic\n value previously set will be applied.", + "annotations": [] + }, + { + "name": "_triggerFetch", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fetchItemsAtOffset", + "returnType": "Future", + "signature": [ + { + "name": "offset", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "fetchPageAtOffset", + "returnType": "Future", + "signature": [ + { + "name": "offset", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Fetch items at a specific offset, normalized to the nearest page size\n It makes sense to use this strategy in order to avoid fetching items\n that are already loaded.", + "annotations": [] + }, + { + "name": "getAllLoadedItems", + "returnType": "List", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getItemAt", + "returnType": "LdPaginatorItem?", + "signature": [ + { + "name": "position", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getItemById", + "returnType": "LdPaginatorItem?", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getItemIndexById", + "returnType": "int?", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "isItemLoaded", + "returnType": "bool", + "signature": [ + { + "name": "position", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "refreshList", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "replaceItems", + "returnType": "void", + "signature": [ + { + "name": "items", + "description": "", + "type": "Map>", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "reset", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "rollbackItemCreation", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "rollbackItemDeletion", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Rolls back the deletion of an item.\n This will restore the item to its previous state.", + "annotations": [] + }, + { + "name": "rollbackItemUpdate", + "returnType": "Future", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newValue", + "description": "", + "type": "T?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Rolls back the update of an item.x\n This will restore the item to its previous state.", + "annotations": [] + }, + { + "name": "scheduleItemCreation", + "returnType": "int", + "signature": [ + { + "name": "item", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "index", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Adds an item to the paginator at the specified index,\n or at the first available slot if no index is given.\n Returns the index of the item.", + "annotations": [] + }, + { + "name": "scheduleItemDeletion", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Schedules the deletion of an item.\n This will mark the item as being deleted. Gives the app the opportunity\n to make an api call, or show an exit animation", + "annotations": [] + }, + { + "name": "scheduleItemUpdate", + "returnType": "void", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newValue", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Schedules the update of an item.\n This will mark the item as being updated. Gives the app the opportunity\n to make an api call, or show an update animation", + "annotations": [] + }, + { + "name": "setItems", + "returnType": "void", + "signature": [ + { + "name": "items", + "description": "", + "type": "List>", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "watchItem", + "returnType": "Stream>", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "watchItems", + "returnType": "Stream>", + "signature": [ + { + "name": "ids", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "watchListOfItems", + "returnType": "Stream>>", + "signature": [ + { + "name": "ids", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_fetchItems", + "returnType": "Future>", + "signature": [ + { + "name": "refresh", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_reset", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_safeExecute", + "returnType": "Future", + "signature": [ + { + "name": "operation", + "description": "", + "type": "Future Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_setBusy", + "returnType": "void", + "signature": [ + { + "name": "isBusy", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_setError", + "returnType": "void", + "signature": [ + { + "name": "error", + "description": "", + "type": "Object?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stackTrace", + "description": "", + "type": "StackTrace?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updated", + "returnType": "Future", + "signature": [ + { + "name": "item", + "description": "", + "type": "LdPaginatorItem?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "_removeAt", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "notifyListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Call this method whenever the object changes, to notify any clients the\n object may have changed. Listeners that are added during this iteration\n will not be visited. Listeners that are removed during this iteration will\n not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n This method must not be called after [dispose] has been called.\n\n Surprising behavior can result when reentrantly removing a listener (e.g.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "fromList", + "returnType": "LdRepository", + "signature": [ + { + "name": "list", + "description": "", + "type": "List", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "filters", + "description": "", + "type": "Set>?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "sortOptions", + "description": "", + "type": "List>?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "_fetchListPaginator", + "returnType": "Future>", + "signature": [ + { + "name": "offset", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "pageSize", + "description": "", + "type": "int", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "pageToken", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "of", + "returnType": "LdRepository", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "maybeOf", + "returnType": "LdRepository?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "updateFilter", + "returnType": "Future", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "updater", + "description": "", + "type": "LdFilterOption Function(LdFilterOption?)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "updateSortOption", + "returnType": "Future", + "signature": [ + { + "name": "sortOption", + "description": "", + "type": "LdSortOption", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "setActiveSortOption", + "returnType": "Future", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "applyOptimisticFilterAndSorting", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "initWithSelection", + "returnType": "Future", + "signature": [ + { + "name": "selection", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getById", + "returnType": "Future", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "skipCache", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "delete", + "returnType": "Future", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "updateBatch", + "returnType": "Future", + "signature": [ + { + "name": "items", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "update", + "returnType": "Future", + "signature": [ + { + "name": "id", + "description": "", + "type": "IdType", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "newValue", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "create", + "returnType": "Future", + "signature": [ + { + "name": "newValue", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "index", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "deleteBatch", + "returnType": "Future", + "signature": [ + { + "name": "ids", + "description": "", + "type": "Set", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getSearchConfig", + "returnType": "LdSearchConfig?", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdPaginator", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/data/repository.dart", + "name": "FetchListWithParameters", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [], + "type": "typedef", + "aliasedType": "Future> Function({Set>? filters, required int offset, required int pageSize, String? pageToken, List>? sortOptions})", + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_scrollable_detail_view.dart", + "name": "LdMonkeyScrollableDetailView", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildDetail", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorItem)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "buildDetail", + "type": "Widget Function(BuildContext, LdPaginatorItem)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_stack_detail_view.dart", + "name": "LdMonkeyStackDetailView", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "buildDetail", + "description": "", + "type": "Widget Function(BuildContext, LdPaginatorItem)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "buildDetail", + "type": "Widget Function(BuildContext, LdPaginatorItem)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_detail_state.dart", + "name": "LdMonkeyDetailState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "deletedItems", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {}", + "annotations": [] + }, + { + "name": "repository", + "description": "", + "type": "LdRepository?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "repository", + "type": "LdRepository?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "deletedItems", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "copyWith", + "returnType": "LdMonkeyDetailState", + "signature": [ + { + "name": "repository", + "description": "", + "type": "LdRepository?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "deletedItems", + "description": "", + "type": "Set?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/monkey/monkey_detail_modal.dart", + "name": "ldMonkeyDetailModal", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ldMonkeyDetailModal", + "returnType": "LdModalRoute", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "detailPage", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/collapse.dart", + "name": "LdCollapse", + "isNullSafe": true, + "description": " A utility to collapse some content", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "collapsed", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "axis", + "description": "", + "type": "Axis", + "named": true, + "required": false, + "defaultValue": "Axis.vertical", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": " Widget to collapse", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "collapsed", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "axis", + "type": "Axis", + "description": " Which direction to collapse", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "_LdCollapseState", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/collapse.dart", + "name": "_LdCollapseState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_ticker", + "type": "Ticker?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickerModeNotifier", + "type": "ValueListenable?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_controller", + "type": "AnimationController?", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdCollapse", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "createTicker", + "returnType": "Ticker", + "signature": [ + { + "name": "onTick", + "description": "", + "type": "void Function(Duration)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Creates a ticker with the given callback.\n\n The kind of ticker provided depends on the kind of ticker provider.", + "annotations": [ + "@factory" + ] + }, + { + "name": "_updateTicker", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickerModeNotifier", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "SingleTickerProviderStateMixin" + ] + }, + { + "filePath": "lib/src/liquid_orb.dart", + "name": "LdOrb", + "isNullSafe": true, + "description": " an animated illustration of an orb filled with liquid that has some waves and a [filling] level.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "filling", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "150", + "annotations": [] + }, + { + "name": "paintBackground", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "size", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "filling", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "paintBackground", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/liquid_orb.dart", + "name": "_LdOrbState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickers", + "type": "Set?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickerModeNotifier", + "type": "ValueListenable?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_animationController", + "type": "AnimationController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tween", + "type": "Tween", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_animation", + "type": "Animation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_angle", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_streamSubscription", + "type": "StreamSubscription?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_fill", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdOrb", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "createTicker", + "returnType": "Ticker", + "signature": [ + { + "name": "onTick", + "description": "", + "type": "void Function(Duration)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Creates a ticker with the given callback.\n\n The kind of ticker provided depends on the kind of ticker provider.", + "annotations": [ + "@factory" + ] + }, + { + "name": "_removeTicker", + "returnType": "void", + "signature": [ + { + "name": "ticker", + "description": "", + "type": "_WidgetTicker", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickers", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickerModeNotifier", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "TickerProviderStateMixin" + ] + }, + { + "filePath": "lib/src/liquid_orb.dart", + "name": "ReflectionPainter", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "orbSize", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_repaint", + "type": "Listenable?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "semanticsBuilder", + "type": "List Function(Size)?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "theme", + "type": "LdTheme", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "inset", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "orbSize", + "type": "Size", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "paint", + "returnType": "void", + "signature": [ + { + "name": "canvas", + "description": "", + "type": "Canvas", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "shouldRebuildSemantics", + "returnType": "bool", + "signature": [ + { + "name": "oldDelegate", + "description": "", + "type": "CustomPainter", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever a new instance of the custom painter delegate class is\n provided to the [RenderCustomPaint] object, or any time that a new\n [CustomPaint] object is created with a new instance of the custom painter\n delegate class (which amounts to the same thing, because the latter is\n implemented in terms of the former).\n\n If the new instance would cause [semanticsBuilder] to create different\n semantics information, then this method should return true, otherwise it\n should return false.\n\n If the method returns false, then the [semanticsBuilder] call might be\n optimized away.\n\n It's possible that the [semanticsBuilder] will get called even if\n [shouldRebuildSemantics] would return false. For example, it is called\n when the [CustomPaint] is rendered for the very first time, or when the\n box changes its size.\n\n By default this method delegates to [shouldRepaint] under the assumption\n that in most cases semantics change when something new is drawn.", + "annotations": [] + }, + { + "name": "shouldRepaint", + "returnType": "bool", + "signature": [ + { + "name": "oldDelegate", + "description": "", + "type": "CustomPainter", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "hitTest", + "returnType": "bool?", + "signature": [ + { + "name": "position", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever a hit test is being performed on an object that is using\n this custom paint delegate.\n\n The given point is relative to the same coordinate space as the last\n [paint] call.\n\n The default behavior is to consider all points to be hits for\n background painters, and no points to be hits for foreground painters.\n\n Return true if the given position corresponds to a point on the drawn\n image that should be considered a \"hit\", false if it corresponds to a\n point that should be considered outside the painted image, and null to use\n the default behavior.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "CustomPainter", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/liquid_orb.dart", + "name": "_OrbPainter", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "_orbSize", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fillPercentage", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animationProgress", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "paintBackground", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_repaint", + "type": "Listenable?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "semanticsBuilder", + "type": "List Function(Size)?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_orbSize", + "type": "Size", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "fillPercentage", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "paintBackground", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "animationProgress", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "theme", + "type": "LdTheme", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "inset", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "width", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "height", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "paint", + "returnType": "void", + "signature": [ + { + "name": "canvas", + "description": "", + "type": "Canvas", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "shouldRebuildSemantics", + "returnType": "bool", + "signature": [ + { + "name": "oldDelegate", + "description": "", + "type": "CustomPainter", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever a new instance of the custom painter delegate class is\n provided to the [RenderCustomPaint] object, or any time that a new\n [CustomPaint] object is created with a new instance of the custom painter\n delegate class (which amounts to the same thing, because the latter is\n implemented in terms of the former).\n\n If the new instance would cause [semanticsBuilder] to create different\n semantics information, then this method should return true, otherwise it\n should return false.\n\n If the method returns false, then the [semanticsBuilder] call might be\n optimized away.\n\n It's possible that the [semanticsBuilder] will get called even if\n [shouldRebuildSemantics] would return false. For example, it is called\n when the [CustomPaint] is rendered for the very first time, or when the\n box changes its size.\n\n By default this method delegates to [shouldRepaint] under the assumption\n that in most cases semantics change when something new is drawn.", + "annotations": [] + }, + { + "name": "shouldRepaint", + "returnType": "bool", + "signature": [ + { + "name": "oldDelegate", + "description": "", + "type": "CustomPainter", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "hitTest", + "returnType": "bool?", + "signature": [ + { + "name": "position", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever a hit test is being performed on an object that is using\n this custom paint delegate.\n\n The given point is relative to the same coordinate space as the last\n [paint] call.\n\n The default behavior is to consider all points to be hits for\n background painters, and no points to be hits for foreground painters.\n\n Return true if the given position corresponds to a point on the drawn\n image that should be considered a \"hit\", false if it corresponds to a\n point that should be considered outside the painted image, and null to use\n the default behavior.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_positionOnCircle", + "returnType": "Offset", + "signature": [ + { + "name": "left", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "CustomPainter", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/size_notifier.dart", + "name": "MeasureSizeRenderObject", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "onSizeChange", + "description": "", + "type": "void Function(Size)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_layoutCacheStorage", + "type": "_LayoutCacheStorage", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_computingThisDryLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_computingThisDryBaseline", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_size", + "type": "Size?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugActivePointers", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasSize", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "size", + "type": "Size", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "semanticBounds", + "type": "Rect", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "constraints", + "type": "Constraints", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "paintBounds", + "type": "Rect", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDisposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "parentData", + "type": "ParentData?", + "description": " Data for use by the parent render object.\n\n The parent data is used by the render object that lays out this object\n (typically this object's parent in the render tree) to store information\n relevant to itself and to any other nodes who happen to know exactly what\n the data means. The parent data is opaque to the child.\n\n * The parent data field must not be directly set, except by calling\n [setupParentData] on the parent node.\n * The parent data can be set before the child is added to the parent, by\n calling [setupParentData] on the future parent node.\n * The conventions for using the parent data depend on the layout protocol\n used between the parent and child. For example, in box layout, the\n parent data is completely opaque but in sector layout the child is\n permitted to read some fields of the parent data.", + "features": [], + "annotations": [] + }, + { + "name": "_depth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_parent", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugCreator", + "type": "Object?", + "description": " The object responsible for creating this render object.\n\n Used in debug messages.\n\n See also:\n\n * [DebugCreator], which the [widgets] library uses as values for this field.", + "features": [], + "annotations": [] + }, + { + "name": "_debugDoingThisResize", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDoingThisLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCanParentUseSize", + "type": "bool?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugMutationsLocked", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_owner", + "type": "PipelineOwner?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_needsLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isRelayoutBoundary", + "type": "bool?", + "description": " Whether this [RenderObject] is a known relayout boundary.\n\n A relayout boundary is a [RenderObject] whose parent does not rely on the\n child [RenderObject]'s size in its own layout algorithm. In other words,\n if a [RenderObject]'s [performLayout] implementation does not ask the child\n for its size at all, **the child** is a relayout boundary.\n\n The type of \"size\" is typically defined by the coordinate system a\n [RenderObject] subclass uses. For instance, [RenderSliver]s produce\n [SliverGeometry] and [RenderBox]es produce [Size]. A parent [RenderObject]\n may not read the child's size but still depend on the child's layout (using\n a [RenderBox] child's baseline location, for example), this flag does not\n reflect such dependencies and the [RenderObject] subclass must handle those\n cases in its own implementation. See [RenderBox.markNeedsLayout] for an\n example.\n\n Relayout boundaries enable an important layout optimization: the parent not\n depending on the size of a child means the child changing size does not\n affect the layout of the parent. When a relayout boundary is marked as\n needing layout, its parent does not have to be marked as dirty, hence the\n name. For details, see [markNeedsLayout].\n\n This flag is typically set in [RenderObject.layout], and consulted by\n [markNeedsLayout] in deciding whether to recursively mark the parent as\n also needing layout.\n\n The flag is initially set to `null` when [layout] has yet been called, and\n reset to `null` when the parent drops this child via [dropChild].", + "features": [], + "annotations": [] + }, + { + "name": "_doingThisLayoutWithCallback", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_constraints", + "type": "Constraints?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDoingThisPaint", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_wasRepaintBoundary", + "type": "bool", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_layerHandle", + "type": "LayerHandle", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_needsCompositingBitsUpdate", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_needsCompositing", + "type": "bool", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_needsPaint", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_needsCompositedLayerUpdate", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_semantics", + "type": "_RenderObjectSemantics", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "debugDisposed", + "type": "bool?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "depth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "parent", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "semanticsParent", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugDoingThisResize", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugDoingThisLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugCanParentUseSize", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCanPerformMutations", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugLayoutParent", + "type": "RenderObject?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "owner", + "type": "PipelineOwner?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "attached", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugNeedsLayout", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugDoingThisLayoutWithCallback", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sizedByParent", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugDoingThisPaint", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isRepaintBoundary", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "alwaysNeedsCompositing", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "layer", + "type": "ContainerLayer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugLayer", + "type": "ContainerLayer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "needsCompositing", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugNeedsPaint", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugNeedsCompositedLayerUpdate", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugNeedsSemanticsUpdate", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugSemantics", + "type": "SemanticsNode?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_child", + "type": "ChildType?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "ChildType?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "oldSize", + "type": "Size?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onSizeChange", + "type": "void Function(Size)", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "setupParentData", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_computeIntrinsics", + "returnType": "Output", + "signature": [ + { + "name": "type", + "description": "", + "type": "_CachedLayoutCalculation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "input", + "description": "", + "type": "Input", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "computer", + "description": "", + "type": "Output Function(Input)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_computeWithTimeline", + "returnType": "Output", + "signature": [ + { + "name": "type", + "description": "", + "type": "_CachedLayoutCalculation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "input", + "description": "", + "type": "Input", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "computer", + "description": "", + "type": "Output Function(Input)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "getMinIntrinsicWidth", + "returnType": "double", + "signature": [ + { + "name": "height", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the minimum width that this box could be without failing to\n correctly paint its contents within itself, without clipping.\n\n The height argument may give a specific height to assume. The given height\n can be infinite, meaning that the intrinsic width in an unconstrained\n environment is being requested. The given height should never be negative\n or null.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement [computeMinIntrinsicWidth].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "computeMinIntrinsicWidth", + "returnType": "double", + "signature": [ + { + "name": "height", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "getMaxIntrinsicWidth", + "returnType": "double", + "signature": [ + { + "name": "height", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the smallest width beyond which increasing the width never\n decreases the preferred height. The preferred height is the value that\n would be returned by [getMinIntrinsicHeight] for that width.\n\n The height argument may give a specific height to assume. The given height\n can be infinite, meaning that the intrinsic width in an unconstrained\n environment is being requested. The given height should never be negative\n or null.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement\n [computeMaxIntrinsicWidth].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "computeMaxIntrinsicWidth", + "returnType": "double", + "signature": [ + { + "name": "height", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "getMinIntrinsicHeight", + "returnType": "double", + "signature": [ + { + "name": "width", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the minimum height that this box could be without failing to\n correctly paint its contents within itself, without clipping.\n\n The width argument may give a specific width to assume. The given width\n can be infinite, meaning that the intrinsic height in an unconstrained\n environment is being requested. The given width should never be negative\n or null.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement\n [computeMinIntrinsicHeight].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "computeMinIntrinsicHeight", + "returnType": "double", + "signature": [ + { + "name": "width", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "getMaxIntrinsicHeight", + "returnType": "double", + "signature": [ + { + "name": "width", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the smallest height beyond which increasing the height never\n decreases the preferred width. The preferred width is the value that\n would be returned by [getMinIntrinsicWidth] for that height.\n\n The width argument may give a specific width to assume. The given width\n can be infinite, meaning that the intrinsic height in an unconstrained\n environment is being requested. The given width should never be negative\n or null.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement\n [computeMaxIntrinsicHeight].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "computeMaxIntrinsicHeight", + "returnType": "double", + "signature": [ + { + "name": "width", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "getDryLayout", + "returnType": "Size", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the [Size] that this [RenderBox] would like to be given the\n provided [BoxConstraints].\n\n The size returned by this method is guaranteed to be the same size that\n this [RenderBox] computes for itself during layout given the same\n constraints.\n\n This function should only be called on one's children. Calling this\n function couples the child with the parent so that when the child's layout\n changes, the parent is notified (via [markNeedsLayout]).\n\n This layout is called \"dry\" layout as opposed to the regular \"wet\" layout\n run performed by [performLayout] because it computes the desired size for\n the given constraints without changing any internal state.\n\n Calling this function is expensive as it can result in O(N^2) behavior.\n\n Do not override this method. Instead, implement [computeDryLayout].", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "_computeDryLayout", + "returnType": "Size", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "computeDryLayout", + "returnType": "Size", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@protected" + ] + }, + { + "name": "getDryBaseline", + "returnType": "double?", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns the distance from the top of the box to the first baseline of the\n box's contents for the given `constraints`, or `null` if this [RenderBox]\n does not have any baselines.\n\n This method calls [computeDryBaseline] under the hood and caches the result.\n [RenderBox] subclasses typically don't overridden [getDryBaseline]. Instead,\n consider overriding [computeDryBaseline] such that it returns a baseline\n location that is consistent with [getDistanceToActualBaseline]. See the\n documentation for the [computeDryBaseline] method for more details.\n\n This method is usually called by the [computeDryBaseline] or the\n [computeDryLayout] implementation of a parent [RenderBox] to get the\n baseline location of a [RenderBox] child. Unlike [getDistanceToBaseline],\n this method takes a [BoxConstraints] as an argument and computes the\n baseline location as if the [RenderBox] was laid out by the parent using\n that [BoxConstraints].\n\n The \"dry\" in the method name means this method, like [getDryLayout], has\n no observable side effects when called, as opposed to \"wet\" layout methods\n such as [performLayout] (which changes this [RenderBox]'s [size], and the\n offsets of its children if any). Since this method does not depend on the\n current layout, unlike [getDistanceToBaseline], it's ok to call this method\n when this [RenderBox]'s layout is outdated.\n\n Similar to the intrinsic width/height and [getDryLayout], calling this\n function in [performLayout] is expensive, as it can result in O(N^2) layout\n performance, where N is the number of render objects in the render subtree.\n Typically this method should be only called by the parent [RenderBox]'s\n [computeDryBaseline] or [computeDryLayout] implementation.", + "annotations": [] + }, + { + "name": "_computeDryBaseline", + "returnType": "BaselineOffset", + "signature": [ + { + "name": "pair", + "description": "", + "type": "(BoxConstraints, TextBaseline)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "computeDryBaseline", + "returnType": "double?", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@protected" + ] + }, + { + "name": "debugCannotComputeDryLayout", + "returnType": "bool", + "signature": [ + { + "name": "reason", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "error", + "description": "", + "type": "FlutterError?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called from [computeDryLayout] or [computeDryBaseline] within an assert if\n the given [RenderBox] subclass does not support calculating a dry layout.\n\n When asserts are enabled and [debugCheckingIntrinsics] is not true, this\n method will either throw the provided [FlutterError] or it will create and\n throw a [FlutterError] with the provided `reason`. Otherwise, it will\n return true.\n\n One of the arguments has to be provided.\n\n See also:\n\n * [computeDryLayout], which lists some reasons why it may not be feasible\n to compute the dry layout.", + "annotations": [] + }, + { + "name": "debugAdoptSize", + "returnType": "Size", + "signature": [ + { + "name": "value", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Claims ownership of the given [Size].\n\n In debug mode, the [RenderBox] class verifies that [Size] objects obtained\n from other [RenderBox] objects are only used according to the semantics of\n the [RenderBox] protocol, namely that a [Size] from a [RenderBox] can only\n be used by its parent, and then only if `parentUsesSize` was set.\n\n Sometimes, a [Size] that can validly be used ends up no longer being valid\n over time. The common example is a [Size] taken from a child that is later\n removed from the parent. In such cases, this method can be called to first\n check whether the size can legitimately be used, and if so, to then create\n a new [Size] that can be used going forward, regardless of what happens to\n the original owner.", + "annotations": [] + }, + { + "name": "debugResetSize", + "returnType": "void", + "signature": [], + "features": [], + "description": " If a subclass has a \"size\" (the state controlled by `parentUsesSize`,\n whatever it is in the subclass, e.g. the actual `size` property of\n [RenderBox]), and the subclass verifies that in debug mode this \"size\"\n property isn't used when [debugCanParentUseSize] isn't set, then that\n subclass should override [debugResetSize] to reapply the current values of\n [debugCanParentUseSize] to that state.", + "annotations": [ + "@protected" + ] + }, + { + "name": "getDistanceToBaseline", + "returnType": "double?", + "signature": [ + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onlyReal", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Returns the distance from the y-coordinate of the position of the box to\n the y-coordinate of the first given baseline in the box's contents.\n\n Used by certain layout models to align adjacent boxes on a common\n baseline, regardless of padding, font size differences, etc. If there is\n no baseline, this function returns the distance from the y-coordinate of\n the position of the box to the y-coordinate of the bottom of the box\n (i.e., the height of the box) unless the caller passes true\n for `onlyReal`, in which case the function returns null.\n\n Only call this function after calling [layout] on this box. You\n are only allowed to call this from the parent of this box during\n that parent's [performLayout] or [paint] functions.\n\n When implementing a [RenderBox] subclass, to override the baseline\n computation, override [computeDistanceToActualBaseline].\n\n See also:\n\n * [getDryBaseline], which returns the baseline location of this\n [RenderBox] at a certain [BoxConstraints].", + "annotations": [] + }, + { + "name": "getDistanceToActualBaseline", + "returnType": "double?", + "signature": [ + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Calls [computeDistanceToActualBaseline] and caches the result.\n\n This function must only be called from [getDistanceToBaseline] and\n [computeDistanceToActualBaseline]. Do not call this function directly from\n outside those two methods.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "computeDistanceToActualBaseline", + "returnType": "double?", + "signature": [ + { + "name": "baseline", + "description": "", + "type": "TextBaseline", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugAssertDoesMeetConstraints", + "returnType": "void", + "signature": [], + "features": [ + "abstract" + ], + "description": " Verify that the object's constraints are being met. Override this function\n in a subclass to verify that your state matches the constraints object.\n This function is only called when asserts are enabled (i.e. in debug mode)\n and only when needsLayout is false. If the constraints are not met, it\n should assert or throw an exception.", + "annotations": [ + "@protected" + ] + }, + { + "name": "_debugVerifyDryBaselines", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "markNeedsLayout", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object's layout information as dirty, and either register\n this object with its [PipelineOwner], or defer to the parent, depending on\n whether this object is a relayout boundary or not respectively.\n\n ## Background\n\n Rather than eagerly updating layout information in response to writes into\n a render object, we instead mark the layout information as dirty, which\n schedules a visual update. As part of the visual update, the rendering\n pipeline updates the render object's layout information.\n\n This mechanism batches the layout work so that multiple sequential writes\n are coalesced, removing redundant computation.\n\n If a render object's parent indicates that it uses the size of one of its\n render object children when computing its layout information, this\n function, when called for the child, will also mark the parent as needing\n layout. In that case, since both the parent and the child need to have\n their layout recomputed, the pipeline owner is only notified about the\n parent; when the parent is laid out, it will call the child's [layout]\n method and thus the child will be laid out as well.\n\n Once [markNeedsLayout] has been called on a render object,\n [debugNeedsLayout] returns true for that render object until just after\n the pipeline owner has called [layout] on the render object.\n\n ## Special cases\n\n Some subclasses of [RenderObject], notably [RenderBox], have other\n situations in which the parent needs to be notified if the child is\n dirtied (e.g., if the child's intrinsic dimensions or baseline changes).\n Such subclasses override markNeedsLayout and either call\n `super.markNeedsLayout()`, in the normal case, or call\n [markParentNeedsLayout], in the case where the parent needs to be laid out\n as well as the child.\n\n If [sizedByParent] has changed, calls\n [markNeedsLayoutForSizedByParentChange] instead of [markNeedsLayout].", + "annotations": [] + }, + { + "name": "performResize", + "returnType": "void", + "signature": [], + "features": [ + "abstract" + ], + "description": " {@template flutter.rendering.RenderObject.performResize}\n Updates the render objects size using only the constraints.\n\n Do not call this function directly: call [layout] instead. This function\n is called by [layout] when there is actually work to be done by this\n render object during layout. The layout constraints provided by your\n parent are available via the [constraints] getter.\n\n This function is called only if [sizedByParent] is true.\n {@endtemplate}\n\n Subclasses that set [sizedByParent] to true should override this method to\n compute their size. Subclasses of [RenderBox] should consider overriding\n [RenderBox.computeDryLayout] instead.", + "annotations": [ + "@protected" + ] + }, + { + "name": "performLayout", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "hitTest", + "returnType": "bool", + "signature": [ + { + "name": "result", + "description": "", + "type": "BoxHitTestResult", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "Offset", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Determines the set of render objects located at the given position.\n\n Returns true, and adds any render objects that contain the point to the\n given hit test result, if this render object or one of its descendants\n absorbs the hit (preventing objects below this one from being hit).\n Returns false if the hit can continue to other objects below this one.\n\n The caller is responsible for transforming [position] from global\n coordinates to its location relative to the origin of this [RenderBox].\n This [RenderBox] is responsible for checking whether the given position is\n within its bounds.\n\n If transforming is necessary, [BoxHitTestResult.addWithPaintTransform],\n [BoxHitTestResult.addWithPaintOffset], or\n [BoxHitTestResult.addWithRawTransform] need to be invoked by the caller\n to record the required transform operations in the [HitTestResult]. These\n methods will also help with applying the transform to `position`.\n\n Hit testing requires layout to be up-to-date but does not require painting\n to be up-to-date. That means a render object can rely upon [performLayout]\n having been called in [hitTest] but cannot rely upon [paint] having been\n called. For example, a render object might be a child of a [RenderOpacity]\n object, which calls [hitTest] on its children when its opacity is zero\n even though it does not [paint] its children.", + "annotations": [] + }, + { + "name": "hitTestSelf", + "returnType": "bool", + "signature": [ + { + "name": "position", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Override this method if this render object can be hit even if its\n children were not hit.\n\n Returns true if the specified `position` should be considered a hit\n on this render object.\n\n The caller is responsible for transforming [position] from global\n coordinates to its location relative to the origin of this [RenderBox].\n This [RenderBox] is responsible for checking whether the given position is\n within its bounds.\n\n Used by [hitTest]. If you override [hitTest] and do not call this\n function, then you don't need to implement this function.", + "annotations": [ + "@protected" + ] + }, + { + "name": "hitTestChildren", + "returnType": "bool", + "signature": [ + { + "name": "result", + "description": "", + "type": "BoxHitTestResult", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "position", + "description": "", + "type": "Offset", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "applyPaintTransform", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "transform", + "description": "", + "type": "Matrix4", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "globalToLocal", + "returnType": "Offset", + "signature": [ + { + "name": "point", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "ancestor", + "description": "", + "type": "RenderObject?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Convert the given point from the global coordinate system in logical pixels\n to the local coordinate system for this box.\n\n This method will un-project the point from the screen onto the widget,\n which makes it different from [MatrixUtils.transformPoint].\n\n If the transform from global coordinates to local coordinates is\n degenerate, this function returns [Offset.zero].\n\n If `ancestor` is non-null, this function converts the given point from the\n coordinate system of `ancestor` (which must be an ancestor of this render\n object) instead of from the global coordinate system.\n\n This method is implemented in terms of [getTransformTo].", + "annotations": [] + }, + { + "name": "localToGlobal", + "returnType": "Offset", + "signature": [ + { + "name": "point", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "ancestor", + "description": "", + "type": "RenderObject?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Convert the given point from the local coordinate system for this box to\n the global coordinate system in logical pixels.\n\n If `ancestor` is non-null, this function converts the given point to the\n coordinate system of `ancestor` (which must be an ancestor of this render\n object) instead of to the global coordinate system.\n\n This method is implemented in terms of [getTransformTo]. If the transform\n matrix puts the given `point` on the line at infinity (for instance, when\n the transform matrix is the zero matrix), this method returns (NaN, NaN).", + "annotations": [] + }, + { + "name": "handleEvent", + "returnType": "void", + "signature": [ + { + "name": "event", + "description": "", + "type": "PointerEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "entry", + "description": "", + "type": "HitTestEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Override this method to receive events.", + "annotations": [] + }, + { + "name": "debugHandleEvent", + "returnType": "bool", + "signature": [ + { + "name": "event", + "description": "", + "type": "PointerEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "entry", + "description": "", + "type": "HitTestEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Implements the [debugPaintPointersEnabled] debugging feature.\n\n [RenderBox] subclasses that implement [handleEvent] should call\n [debugHandleEvent] from their [handleEvent] method, as follows:\n\n ```dart\n class RenderFoo extends RenderBox {\n // ...\n\n @override\n void handleEvent(PointerEvent event, HitTestEntry entry) {\n assert(debugHandleEvent(event, entry));\n // ... handle the event ...\n }\n\n // ...\n }\n ```\n\n If you call this for a [PointerDownEvent], make sure you also call it for\n the corresponding [PointerUpEvent] or [PointerCancelEvent].", + "annotations": [] + }, + { + "name": "debugPaint", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Override this method to paint debugging information.", + "annotations": [] + }, + { + "name": "debugPaintSize", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " In debug mode, paints a border around this render box.\n\n Called for every [RenderBox] when [debugPaintSizeEnabled] is true.", + "annotations": [ + "@protected", + "@visibleForTesting" + ] + }, + { + "name": "debugPaintBaselines", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " In debug mode, paints a line for each baseline.\n\n Called for every [RenderBox] when [debugPaintBaselinesEnabled] is true.", + "annotations": [ + "@protected" + ] + }, + { + "name": "debugPaintPointers", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " In debug mode, paints a rectangle if this render box has counted more\n pointer downs than pointer up events.\n\n Called for every [RenderBox] when [debugPaintPointersEnabled] is true.\n\n By default, events are not counted. For details on how to ensure that\n events are counted for your class, see [debugHandleEvent].", + "annotations": [ + "@protected" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " Cause the entire subtree rooted at the given [RenderObject] to be marked\n dirty for layout, paint, etc, so that the effects of a hot reload can be\n seen, or so that the effect of changing a global debug flag (such as\n [debugPaintSizeEnabled]) can be applied.\n\n This is called by the [RendererBinding] in response to the\n `ext.flutter.reassemble` hook, which is used by development tools when the\n application code has changed, to cause the widget tree to pick up any\n changed implementations.\n\n This is expensive and should not be called except during development.\n\n See also:\n\n * [BindingBase.reassembleApplication]", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Release any resources held by this render object.\n\n The object that creates a RenderObject is in charge of disposing it.\n If this render object has created any children directly, it must dispose\n of those children in this method as well. It must not dispose of any\n children that were created by some other object, such as\n a [RenderObjectElement]. Those children will be disposed when that\n element unmounts, which may be delayed if the element is moved to another\n part of the tree.\n\n Implementations of this method must end with a call to the inherited\n method, as in `super.dispose()`.\n\n The object is no longer usable after calling dispose.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "redepthChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Adjust the [depth] of the given [child] to be greater than this node's own\n [depth].\n\n Only call this method from overrides of [redepthChildren].", + "annotations": [ + "@protected" + ] + }, + { + "name": "redepthChildren", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "adoptChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called by subclasses when they decide a render object is a child.\n\n Only for use by subclasses when changing their child lists. Calling this\n in other cases will lead to an inconsistent tree and probably cause crashes.", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "dropChild", + "returnType": "void", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called by subclasses when they decide a render object is no longer a child.\n\n Only for use by subclasses when changing their child lists. Calling this\n in other cases will lead to an inconsistent tree and probably cause crashes.", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "visitChildren", + "returnType": "void", + "signature": [ + { + "name": "visitor", + "description": "", + "type": "void Function(RenderObject)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_reportException", + "returnType": "void", + "signature": [ + { + "name": "method", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "exception", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stack", + "description": "", + "type": "StackTrace", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "attach", + "returnType": "void", + "signature": [ + { + "name": "owner", + "description": "", + "type": "PipelineOwner", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "detach", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_debugRelayoutBoundaryAlreadyMarkedNeedsLayout", + "returnType": "bool", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "markParentNeedsLayout", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object's layout information as dirty, and then defer to\n the parent.\n\n This function should only be called from [markNeedsLayout] or\n [markNeedsLayoutForSizedByParentChange] implementations of subclasses that\n introduce more reasons for deferring the handling of dirty layout to the\n parent. See [markNeedsLayout] for details.\n\n Only call this if [parent] is not null.", + "annotations": [ + "@protected" + ] + }, + { + "name": "markNeedsLayoutForSizedByParentChange", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object's layout information as dirty (like\n [markNeedsLayout]), and additionally also handle any necessary work to\n handle the case where [sizedByParent] has changed value.\n\n This should be called whenever [sizedByParent] might have changed.\n\n Only call this if [parent] is not null.", + "annotations": [] + }, + { + "name": "scheduleInitialLayout", + "returnType": "void", + "signature": [], + "features": [], + "description": " Bootstrap the rendering pipeline by scheduling the very first layout.\n\n Requires this render object to be attached and that this render object\n is the root of the render tree.\n\n See [RenderView] for an example of how this function is used.", + "annotations": [] + }, + { + "name": "_layoutWithoutResize", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "layout", + "returnType": "void", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "Constraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "parentUsesSize", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Compute the layout for this render object.\n\n This method is the main entry point for parents to ask their children to\n update their layout information. The parent passes a constraints object,\n which informs the child as to which layouts are permissible. The child is\n required to obey the given constraints.\n\n If the parent reads information computed during the child's layout, the\n parent must pass true for `parentUsesSize`. In that case, the parent will\n be marked as needing layout whenever the child is marked as needing layout\n because the parent's layout information depends on the child's layout\n information. If the parent uses the default value (false) for\n `parentUsesSize`, the child can change its layout information (subject to\n the given constraints) without informing the parent.\n\n Subclasses should not override [layout] directly. Instead, they should\n override [performResize] and/or [performLayout]. The [layout] method\n delegates the actual work to [performResize] and [performLayout].\n\n The parent's [performLayout] method should call the [layout] of all its\n children unconditionally. It is the [layout] method's responsibility (as\n implemented here) to return early if the child does not need to do any\n work to update its layout information.", + "annotations": [ + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "invokeLayoutCallback", + "returnType": "void", + "signature": [ + { + "name": "callback", + "description": "", + "type": "void Function(T)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Allows mutations to be made to this object's child list (and any\n descendants) as well as to any other dirty nodes in the render tree owned\n by the same [PipelineOwner] as this object. The `callback` argument is\n invoked synchronously, and the mutations are allowed only during that\n callback's execution.\n\n This exists to allow child lists to be built on-demand during layout (e.g.\n based on the object's size), and to enable nodes to be moved around the\n tree as this happens (e.g. to handle [GlobalKey] reparenting), while still\n ensuring that any particular node is only laid out once per frame.\n\n Calling this function disables a number of assertions that are intended to\n catch likely bugs. As such, using this function is generally discouraged.\n\n This function can only be called during layout.", + "annotations": [ + "@protected" + ] + }, + { + "name": "debugRegisterRepaintBoundaryPaint", + "returnType": "void", + "signature": [ + { + "name": "includedParent", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "includedChild", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": " Called, in debug mode, if [isRepaintBoundary] is true, when either the\n this render object or its parent attempt to paint.\n\n This can be used to record metrics about whether the node should actually\n be a repaint boundary.", + "annotations": [] + }, + { + "name": "updateCompositedLayer", + "returnType": "OffsetLayer", + "signature": [ + { + "name": "oldLayer", + "description": "", + "type": "OffsetLayer?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Update the composited layer owned by this render object.\n\n This method is called by the framework when [isRepaintBoundary] is true.\n\n If [oldLayer] is `null`, this method must return a new [OffsetLayer]\n (or subtype thereof). If [oldLayer] is not `null`, then this method must\n reuse the layer instance that is provided - it is an error to create a new\n layer in this instance. The layer will be disposed by the framework when\n either the render object is disposed or if it is no longer a repaint\n boundary.\n\n The [OffsetLayer.offset] property will be managed by the framework and\n must not be updated by this method.\n\n If a property of the composited layer needs to be updated, the render object\n must call [markNeedsCompositedLayerUpdate] which will schedule this method\n to be called without repainting children. If this widget was marked as\n needing to paint and needing a composited layer update, this method is only\n called once.", + "annotations": [] + }, + { + "name": "markNeedsCompositingBitsUpdate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark the compositing state for this render object as dirty.\n\n This is called to indicate that the value for [needsCompositing] needs to\n be recomputed during the next [PipelineOwner.flushCompositingBits] engine\n phase.\n\n When the subtree is mutated, we need to recompute our\n [needsCompositing] bit, and some of our ancestors need to do the\n same (in case ours changed in a way that will change theirs). To\n this end, [adoptChild] and [dropChild] call this method, and, as\n necessary, this method calls the parent's, etc, walking up the\n tree to mark all the nodes that need updating.\n\n This method does not schedule a rendering frame, because since\n it cannot be the case that _only_ the compositing bits changed,\n something else will have scheduled a frame for us.", + "annotations": [] + }, + { + "name": "_updateCompositingBits", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "markNeedsPaint", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object as having changed its visual appearance.\n\n Rather than eagerly updating this render object's display list\n in response to writes, we instead mark the render object as needing to\n paint, which schedules a visual update. As part of the visual update, the\n rendering pipeline will give this render object an opportunity to update\n its display list.\n\n This mechanism batches the painting work so that multiple sequential\n writes are coalesced, removing redundant computation.\n\n Once [markNeedsPaint] has been called on a render object,\n [debugNeedsPaint] returns true for that render object until just after\n the pipeline owner has called [paint] on the render object.\n\n See also:\n\n * [RepaintBoundary], to scope a subtree of render objects to their own\n layer, thus limiting the number of nodes that [markNeedsPaint] must mark\n dirty.", + "annotations": [] + }, + { + "name": "markNeedsCompositedLayerUpdate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this render object as having changed a property on its composited\n layer.\n\n Render objects that have a composited layer have [isRepaintBoundary] equal\n to true may update the properties of that composited layer without repainting\n their children. If this render object is a repaint boundary but does\n not yet have a composited layer created for it, this method will instead\n mark the nearest repaint boundary parent as needing to be painted.\n\n If this method is called on a render object that is not a repaint boundary\n or is a repaint boundary but hasn't been composited yet, it is equivalent\n to calling [markNeedsPaint].\n\n See also:\n\n * [RenderOpacity], which uses this method when its opacity is updated to\n update the layer opacity without repainting children.", + "annotations": [] + }, + { + "name": "_skippedPaintingOnLayer", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "scheduleInitialPaint", + "returnType": "void", + "signature": [ + { + "name": "rootLayer", + "description": "", + "type": "ContainerLayer", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Bootstrap the rendering pipeline by scheduling the very first paint.\n\n Requires that this render object is attached, is the root of the render\n tree, and has a composited layer.\n\n See [RenderView] for an example of how this function is used.", + "annotations": [] + }, + { + "name": "replaceRootLayer", + "returnType": "void", + "signature": [ + { + "name": "rootLayer", + "description": "", + "type": "OffsetLayer", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Replace the layer. This is only valid for the root of a render\n object subtree (whatever object [scheduleInitialPaint] was\n called on).\n\n This might be called if, e.g., the device pixel ratio changed.", + "annotations": [] + }, + { + "name": "_paintWithContext", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "paint", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "PaintingContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "offset", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "paintsChild", + "returnType": "bool", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Whether the given child would be painted if [paint] were called.\n\n Some RenderObjects skip painting their children if they are configured to\n not produce any visible effects. For example, a [RenderOffstage] with\n its `offstage` property set to true, or a [RenderOpacity] with its opacity\n value set to zero.\n\n In these cases, the parent may still supply a non-zero matrix in\n [applyPaintTransform] to inform callers about where it would paint the\n child if the child were painted at all. Alternatively, the parent may\n supply a zeroed out matrix if it would not otherwise be able to determine\n a valid matrix for the child and thus cannot meaningfully determine where\n the child would paint.", + "annotations": [] + }, + { + "name": "getTransformTo", + "returnType": "Matrix4", + "signature": [ + { + "name": "target", + "description": "", + "type": "RenderObject?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " {@template flutter.rendering.RenderObject.getTransformTo}\n Applies the paint transform from this [RenderObject] to the `target`\n [RenderObject].\n\n Returns a matrix that maps the local paint coordinate system to the\n coordinate system of `target`, or a [Matrix4.zero] if the paint transform\n can not be computed.\n\n This method throws an exception when the `target` is not in the same render\n tree as this [RenderObject], as the behavior is undefined.\n\n This method ignores [RenderObject.paintsChild]. This means it will still\n try to compute the paint transform even if this [RenderObject] or\n `target` is currently not visible.\n\n If `target` is null, this method returns a matrix that maps from the\n local paint coordinate system to the coordinate system of the\n [PipelineOwner.rootNode].\n {@endtemplate}\n\n For the render tree owned by the [RendererBinding] (i.e. for the main\n render tree displayed on the device) this means that this method maps to\n the global coordinate system in logical pixels. To get physical pixels,\n use [applyPaintTransform] from the [RenderView] to further transform the\n coordinate.", + "annotations": [] + }, + { + "name": "describeApproximatePaintClip", + "returnType": "Rect?", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a rect in this object's coordinate system that describes\n the approximate bounding box of the clip rect that would be\n applied to the given child during the paint phase, if any.\n\n Returns null if the child would not be clipped.\n\n This is used in the semantics phase to avoid including children\n that are not physically visible.\n\n RenderObjects that respect a [Clip] behavior when painting _must_ respect\n that same behavior when describing this value. For example, if passing\n [Clip.none] to [PaintingContext.pushClipRect] as the `clipBehavior`, then\n the implementation of this method must return null.", + "annotations": [] + }, + { + "name": "describeSemanticsClip", + "returnType": "Rect?", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a rect in this object's coordinate system that describes\n which [SemanticsNode]s produced by the `child` should be included in the\n semantics tree. [SemanticsNode]s from the `child` that are positioned\n outside of this rect will be dropped. Child [SemanticsNode]s that are\n positioned inside this rect, but outside of [describeApproximatePaintClip]\n will be included in the tree marked as hidden. Child [SemanticsNode]s\n that are inside of both rect will be included in the tree as regular\n nodes.\n\n This method only returns a non-null value if the semantics clip rect\n is different from the rect returned by [describeApproximatePaintClip].\n If the semantics clip rect and the paint clip rect are the same, this\n method returns null.\n\n A viewport would typically implement this method to include semantic nodes\n in the semantics tree that are currently hidden just before the leading\n or just after the trailing edge. These nodes have to be included in the\n semantics tree to implement implicit accessibility scrolling on iOS where\n the viewport scrolls implicitly when moving the accessibility focus from\n the last visible node in the viewport to the first hidden one.\n\n See also:\n\n * [RenderViewportBase.cacheExtent], used by viewports to extend their\n semantics clip beyond their approximate paint clip.", + "annotations": [] + }, + { + "name": "scheduleInitialSemantics", + "returnType": "void", + "signature": [], + "features": [], + "description": " Bootstrap the semantics reporting mechanism by marking this node\n as needing a semantics update.\n\n Requires that this render object is attached, and is the root of\n the render tree.\n\n See [RendererBinding] for an example of how this function is used.", + "annotations": [] + }, + { + "name": "describeSemanticsConfiguration", + "returnType": "void", + "signature": [ + { + "name": "config", + "description": "", + "type": "SemanticsConfiguration", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Report the semantics of this node, for example for accessibility purposes.\n\n This method should be overridden by subclasses that have interesting\n semantic information.\n\n The given [SemanticsConfiguration] object is mutable and should be\n annotated in a manner that describes the current state. No reference\n should be kept to that object; mutating it outside of the context of the\n [describeSemanticsConfiguration] call (for example as a result of\n asynchronous computation) will at best have no useful effect and at worse\n will cause crashes as the data will be in an inconsistent state.\n\n {@tool snippet}\n\n The following snippet will describe the node as a button that responds to\n tap actions.\n\n ```dart\n abstract class SemanticButtonRenderObject extends RenderObject {\n @override\n void describeSemanticsConfiguration(SemanticsConfiguration config) {\n super.describeSemanticsConfiguration(config);\n config\n ..onTap = _handleTap\n ..label = 'I am a button'\n ..isButton = true;\n }\n\n void _handleTap() {\n // Do something.\n }\n }\n ```\n {@end-tool}", + "annotations": [ + "@protected" + ] + }, + { + "name": "sendSemanticsEvent", + "returnType": "void", + "signature": [ + { + "name": "semanticsEvent", + "description": "", + "type": "SemanticsEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Sends a [SemanticsEvent] associated with this render object's [SemanticsNode].\n\n If this render object has no semantics information, the first parent\n render object with a non-null semantic node is used.\n\n If semantics are disabled, no events are dispatched.\n\n See [SemanticsNode.sendEvent] for a full description of the behavior.", + "annotations": [] + }, + { + "name": "clearSemantics", + "returnType": "void", + "signature": [], + "features": [], + "description": " Removes all semantics from this render object and its descendants.\n\n Should only be called on objects whose [parent] is not a [RenderObject].\n\n Override this method if you instantiate new [SemanticsNode]s in an\n overridden [assembleSemanticsNode] method, to dispose of those nodes.", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "markNeedsSemanticsUpdate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Mark this node as needing an update to its semantics description.\n\n This must be called whenever the semantics configuration of this\n [RenderObject] as annotated by [describeSemanticsConfiguration] changes in\n any way to update the semantics tree.", + "annotations": [] + }, + { + "name": "visitChildrenForSemantics", + "returnType": "void", + "signature": [ + { + "name": "visitor", + "description": "", + "type": "void Function(RenderObject)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when collecting the semantics of this node.\n\n The implementation has to return the children in paint order skipping all\n children that are not semantically relevant (e.g. because they are\n invisible).\n\n The default implementation mirrors the behavior of\n [visitChildren] (which is supposed to walk all the children).", + "annotations": [] + }, + { + "name": "assembleSemanticsNode", + "returnType": "void", + "signature": [ + { + "name": "node", + "description": "", + "type": "SemanticsNode", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "config", + "description": "", + "type": "SemanticsConfiguration", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "children", + "description": "", + "type": "Iterable", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Assemble the [SemanticsNode] for this [RenderObject].\n\n If [describeSemanticsConfiguration] sets\n [SemanticsConfiguration.isSemanticBoundary] to true, this method is called\n with the `node` created for this [RenderObject], the `config` to be\n applied to that node and the `children` [SemanticsNode]s that descendants\n of this RenderObject have generated.\n\n By default, the method will annotate `node` with `config` and add the\n `children` to it.\n\n Subclasses can override this method to add additional [SemanticsNode]s\n to the tree. If new [SemanticsNode]s are instantiated in this method\n they must be disposed in [clearSemantics].", + "annotations": [] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "showOnScreen", + "returnType": "void", + "signature": [ + { + "name": "descendant", + "description": "", + "type": "RenderObject?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "rect", + "description": "", + "type": "Rect?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "duration", + "description": "", + "type": "Duration", + "named": true, + "required": false, + "defaultValue": "Duration.zero", + "annotations": [] + }, + { + "name": "curve", + "description": "", + "type": "Curve", + "named": true, + "required": false, + "defaultValue": "Curves.ease", + "annotations": [] + } + ], + "features": [], + "description": " Attempt to make (a portion of) this or a descendant [RenderObject] visible\n on screen.\n\n If `descendant` is provided, that [RenderObject] is made visible. If\n `descendant` is omitted, this [RenderObject] is made visible.\n\n The optional `rect` parameter describes which area of that [RenderObject]\n should be shown on screen. If `rect` is null, the entire\n [RenderObject] (as defined by its [paintBounds]) will be revealed. The\n `rect` parameter is interpreted relative to the coordinate system of\n `descendant` if that argument is provided and relative to this\n [RenderObject] otherwise.\n\n The `duration` parameter can be set to a non-zero value to bring the\n target object on screen in an animation defined by `curve`.\n\n See also:\n\n * [RenderViewportBase.showInViewport], which [RenderViewportBase] and\n [SingleChildScrollView] delegate this method to.", + "annotations": [] + }, + { + "name": "describeForError", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle", + "named": true, + "required": false, + "defaultValue": "DiagnosticsTreeStyle.shallow", + "annotations": [] + } + ], + "features": [], + "description": " Adds a debug representation of a [RenderObject] optimized for including in\n error messages.\n\n The default [style] of [DiagnosticsTreeStyle.shallow] ensures that all of\n the properties of the render object are included in the error output but\n none of the children of the object are.\n\n You should always include a RenderObject in an error message if it is the\n [RenderObject] causing the failure or contract violation of the error.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugValidateChild", + "returnType": "bool", + "signature": [ + { + "name": "child", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Checks whether the given render object has the correct [runtimeType] to be\n a child of this render object.\n\n Does nothing if assertions are disabled.\n\n Always returns true.", + "annotations": [] + }, + { + "name": "computeSizeForNoChild", + "returnType": "Size", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Calculate the size the [RenderProxyBox] would have under the given\n [BoxConstraints] for the case where it does not have a child.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "RenderProxyBox", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/size_notifier.dart", + "name": "MeasureSize", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onSizeChange", + "description": "", + "type": "dynamic Function(Size)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "child", + "type": "Widget?", + "description": " The widget below this widget in the tree.\n\n {@macro flutter.widgets.ProxyWidget.child}", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onSizeChange", + "type": "dynamic Function(Size)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createRenderObject", + "returnType": "RenderObject", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "updateRenderObject", + "returnType": "void", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "renderObject", + "description": "", + "type": "MeasureSizeRenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUnmountRenderObject", + "returnType": "void", + "signature": [ + { + "name": "renderObject", + "description": "", + "type": "RenderObject", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " This method is called when a RenderObject that was previously\n associated with this widget is removed from the render tree.\n The provided [RenderObject] will be of the same type as the one created by\n this widget's [createRenderObject] method.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "SingleChildRenderObjectWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/utils.dart", + "name": "_LdEnterTextModal", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "description", + "description": "", + "type": "String?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "additionalContent", + "description": "", + "type": "Widget?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inputHint", + "description": "", + "type": "String?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inputLabel", + "description": "", + "type": "String?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowDismiss", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialValue", + "description": "", + "type": "String?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "description", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "title", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "additionalContent", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "inputHint", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "inputLabel", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialValue", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "allowDismiss", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_LdEnterTextModal>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/utils.dart", + "name": "_LdEnterTextModalState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_controller", + "type": "TextEditingController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_LdEnterTextModal", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/utils.dart", + "name": "ldConfirmModal", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ldConfirmModal", + "returnType": "Future", + "signature": [ + { + "name": "description", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "positive", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "negative", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "additionalContent", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "confirmColor", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "cancelColor", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "indicatorType", + "description": "", + "type": "LdIndicatorType?", + "named": true, + "required": false, + "defaultValue": "LdIndicatorType.warning", + "annotations": [] + }, + { + "name": "useRootNavigator", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "allowDismiss", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/utils.dart", + "name": "ldEnterTextModal", + "isNullSafe": true, + "description": "", + "constructors": [], + "properties": [], + "methods": [ + { + "name": "ldEnterTextModal", + "returnType": "Future", + "signature": [ + { + "name": "description", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "title", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "additionalContent", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "useRootNavigator", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "initialValue", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inputHint", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "inputLabel", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "allowDismiss", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "function", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/modal_builder.dart", + "name": "LdModalBuilder", + "isNullSafe": true, + "description": " A utility widget that displays a sheet when a button is pressed.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "builder", + "description": "", + "type": "Widget Function(BuildContext, Future Function())", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "modal", + "description": "", + "type": "LdModalRoute", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "useRootNavigator", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "builder", + "type": "Widget Function(BuildContext, Future Function())", + "description": " The builder for the button that opens the sheet. Calll the `onPress` callback to open the sheet.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "modal", + "type": "LdModalRoute", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "useRootNavigator", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/modal_builder.dart", + "name": "LdModalBuilderState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdModalBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "open", + "returnType": "Future", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/modal_type_mode.dart", + "name": "LdModalTypeMode", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "auto", + "type": "LdModalTypeMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "sheet", + "type": "LdModalTypeMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "dialog", + "type": "LdModalTypeMode", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/modal.dart", + "name": "LdModalPage", + "isNullSafe": true, + "description": " A Page implementation for use with GoRouter that displays an LdModal.\n\n This replaces the deprecated LdModalPage class.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "LocalKey?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "builder", + "description": "", + "type": "LdModalRoute Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "LocalKey?", + "description": " The key associated with this page.\n\n This key will be used for comparing pages in [canUpdate].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "restorationId", + "type": "String?", + "description": " Restoration ID to save and restore the state of the [Route] configured by\n this page.\n\n If no restoration ID is provided, the [Route] will not restore its state.\n\n See also:\n\n * [RestorationManager], which explains how state restoration works in\n Flutter.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onPopInvoked", + "type": "void Function(bool, T?)", + "description": " Called after a pop on the associated route was handled.\n\n It's not possible to prevent the pop from happening at the time that this\n method is called; the pop has already happened. Use [canPop] to\n disable pops in advance.\n\n This will still be called even when the pop is canceled. A pop is canceled\n when the associated [Route.popDisposition] returns false, or when\n [canPop] is set to false. The `didPop` parameter indicates whether or not\n the back navigation actually happened successfully.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "canPop", + "type": "bool", + "description": " When false, blocks the associated route from being popped.\n\n If this is set to false for first page in the Navigator. It prevents\n Flutter app from exiting.\n\n If there are any [PopScope] widgets in a route's widget subtree,\n each of their `canPop` must be `true`, in addition to this canPop, in\n order for the route to be able to pop.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "name", + "type": "String?", + "description": " The name of the route (e.g., \"/settings\").\n\n If null, the route is anonymous.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "arguments", + "type": "Object?", + "description": " The arguments passed to this route.\n\n May be used when building the route, e.g. in [Navigator.onGenerateRoute].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "builder", + "type": "LdModalRoute Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "canUpdate", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Page", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Whether this page can be updated with the [other] page.\n\n Two pages are consider updatable if they have same the [runtimeType] and\n [key].", + "annotations": [] + }, + { + "name": "createRoute", + "returnType": "Route", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Page", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/modal.dart", + "name": "LdModalRoute", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "barrierDismissible", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "pageBuilder", + "description": "", + "type": "Widget Function(BuildContext)", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "modalTypeMode", + "description": "", + "type": "LdModalTypeMode", + "named": true, + "required": false, + "defaultValue": "LdModalTypeMode.auto", + "annotations": [] + }, + { + "name": "scaleParent", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "maintainState", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "dialogSize", + "description": "", + "type": "LdSize?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "sheetBorderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fixedDialogSize", + "description": "", + "type": "Size?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "sheetAspectRatio", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "dialogBorderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "sheetBreakpoint", + "description": "", + "type": "double?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "sheetInsets", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "barrierLabel", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "settings", + "description": "", + "type": "RouteSettings?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "fullscreenDialog", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "allowSnapshotting", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_barrierDismissible", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "opaque", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "barrierDismissible", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "popGestureEnabled", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "filter", + "type": "ImageFilter?", + "description": " The filter to add to the barrier.\n\n If given, this filter will be applied to the modal barrier using\n [BackdropFilter]. This allows blur effects, for example.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "traversalEdgeBehavior", + "type": "TraversalEdgeBehavior?", + "description": " Controls the transfer of focus beyond the first and the last items of a\n [FocusScopeNode].\n\n If set to null, [Navigator.routeTraversalEdgeBehavior] is used.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "directionalTraversalEdgeBehavior", + "type": "TraversalEdgeBehavior?", + "description": " Controls the directional transfer of focus beyond the first and the last\n items of a [FocusScopeNode].\n\n If set to null, [Navigator.routeDirectionalTraversalEdgeBehavior] is used.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "receivedTransition", + "type": "Widget? Function(BuildContext, Animation, Animation, bool, Widget?)?", + "description": " The [DelegatedTransitionBuilder] received from the route above this one in\n the navigation stack.\n\n {@macro flutter.widgets.delegatedTransition}\n\n The `receivedTransition` will use the above route's [delegatedTransition] in\n order to show the right route transition when the above route either enters\n or leaves the navigation stack. If not null, the `receivedTransition` will\n wrap the route content.", + "features": [], + "annotations": [ + "@visibleForTesting" + ] + }, + { + "name": "_offstage", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_animationProxy", + "type": "ProxyAnimation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_secondaryAnimationProxy", + "type": "ProxyAnimation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_willPopCallbacks", + "type": "List Function()>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_popEntries", + "type": "Set>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_scopeKey", + "type": "GlobalKey<_ModalScopeState>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_subtreeKey", + "type": "GlobalKey>", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_storageBucket", + "type": "PageStorageBucket", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_modalBarrier", + "type": "OverlayEntry", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_modalScopeCache", + "type": "Widget?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_modalScope", + "type": "OverlayEntry", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "delegatedTransition", + "type": "Widget? Function(BuildContext, Animation, Animation, bool, Widget?)?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "semanticsDismissible", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "barrierColor", + "type": "Color?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "barrierLabel", + "type": "String?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "barrierCurve", + "type": "Curve", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "maintainState", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [ + "@override" + ] + }, + { + "name": "popGestureInProgress", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "offstage", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "subtreeContext", + "type": "BuildContext?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "animation", + "type": "Animation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "secondaryAnimation", + "type": "Animation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "popDisposition", + "type": "RoutePopDisposition", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasScopedWillPopCallback", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "canPop", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "impliesAppBarDismissal", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_transitionCompleter", + "type": "Completer", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_performanceModeRequestHandle", + "type": "PerformanceModeRequestHandle?", + "description": " Handle to the performance mode request.\n\n When the route is animating, the performance mode is requested. It is then\n disposed when the animation ends. Requesting [DartPerformanceMode.latency]\n indicates to the engine that the transition is latency sensitive and to delay\n non-essential work while this handle is active.", + "features": [], + "annotations": [] + }, + { + "name": "_popFinalized", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_animation", + "type": "Animation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_controller", + "type": "AnimationController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_secondaryAnimation", + "type": "ProxyAnimation", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "willDisposeAnimationController", + "type": "bool", + "description": " Whether to takeover the [controller] created by [createAnimationController].\n\n If true, this route will call [AnimationController.dispose] when the\n controller is no longer needed.\n If false, the controller should be disposed by whoever owned it.\n\n It defaults to `true`.", + "features": [], + "annotations": [] + }, + { + "name": "_simulation", + "type": "Simulation?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_result", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_trainHoppingListenerRemover", + "type": "void Function()?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "completed", + "type": "Future", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "transitionDuration", + "type": "Duration", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "reverseTransitionDuration", + "type": "Duration", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "finishedWhenPopped", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "controller", + "type": "AnimationController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugLabel", + "type": "String", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_overlayEntries", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "overlayEntries", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_requestFocus", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_navigator", + "type": "NavigatorState?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_settings", + "type": "RouteSettings", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_restorationScopeId", + "type": "ValueNotifier", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_popCompleter", + "type": "Completer", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_disposeCompleter", + "type": "Completer", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "requestFocus", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "navigator", + "type": "NavigatorState?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "settings", + "type": "RouteSettings", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_isPageBased", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "restorationScopeId", + "type": "ValueListenable", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "willHandlePopInternally", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "currentResult", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "popped", + "type": "Future", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isCurrent", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isFirst", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hasActiveRouteBelow", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "isActive", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_localHistory", + "type": "List?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_entriesImpliesAppBarDismissal", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_barrierLabel", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "modalTypeMode", + "type": "LdModalTypeMode", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "dialogSize", + "type": "LdSize?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "fixedDialogSize", + "type": "Size?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "sheetAspectRatio", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "sheetBreakpoint", + "type": "double?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "scaleParent", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "sheetBorderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "dialogBorderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "sheetInsets", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "pageBuilder", + "type": "Widget Function(BuildContext)", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_kDialogScaleFactor", + "type": "double", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "_kDialogScaleTween", + "type": "Animatable", + "description": "", + "features": [ + "static", + "final" + ], + "annotations": [] + }, + { + "name": "_kDialogMidUpTween", + "type": "Animatable", + "description": "", + "features": [ + "static", + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "canTransitionTo", + "returnType": "bool", + "signature": [ + { + "name": "nextRoute", + "description": "", + "type": "TransitionRoute", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "canTransitionFrom", + "returnType": "bool", + "signature": [ + { + "name": "previousRoute", + "description": "", + "type": "TransitionRoute", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns true if [previousRoute] should animate when this route\n is pushed on top of it or when then this route is popped off of it.\n\n Subclasses can override this method to restrict the set of routes they\n need to coordinate transitions with.\n\n If true, and `previousRoute.canTransitionTo()` is true, then the\n previous route's [ModalRoute.buildTransitions] `secondaryAnimation` will\n run from 0.0 - 1.0 when this route is pushed on top of\n it. Similarly, if this route is popped off of [previousRoute]\n the previous route's `secondaryAnimation` will run from 1.0 - 0.0.\n\n If false, then the previous route's [ModalRoute.buildTransitions]\n `secondaryAnimation` value will be kAlwaysDismissedAnimation. In\n other words [previousRoute] will not animate when this route is\n pushed on top of it or when then this route is popped off of it.\n\n Returns true by default.\n\n See also:\n\n * [canTransitionTo], which must be true for [previousRoute] for its\n [ModalRoute.buildTransitions] `secondaryAnimation` to run.", + "annotations": [] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Schedule a call to [buildTransitions].\n\n Whenever you need to change internal state for a [ModalRoute] object, make\n the change in a function that you pass to [setState], as in:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n If you just change the state directly without calling [setState], then the\n route will not be scheduled for rebuilding, meaning that its rendering\n will not be updated.", + "annotations": [ + "@protected" + ] + }, + { + "name": "buildPage", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAnimation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "buildTransitions", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAnimation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_buildFlexibleTransitions", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAnimation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "install", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when the route is inserted into the navigator.\n\n Uses this to populate [overlayEntries]. There must be at least one entry in\n this list after [install] has been invoked. The [Navigator] will be in charge\n to add them to the [Overlay] or remove them from it by calling\n [OverlayEntry.remove].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didPush", + "returnType": "TickerFuture", + "signature": [], + "features": [], + "description": " Called after [install] when the route is pushed onto the navigator.\n\n The returned value resolves when the push transition is complete.\n\n The [didAdd] method will be called instead of [didPush] when the route\n immediately appears on screen without any push transition.\n\n The [didChangeNext] and [didChangePrevious] methods are typically called\n immediately after this method is called.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didAdd", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called after [install] when the route is added to the navigator.\n\n This method is called instead of [didPush] when the route immediately\n appears on screen without any push transition.\n\n The [didChangeNext] and [didChangePrevious] methods are typically called\n immediately after this method is called.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "willPop", + "returnType": "Future", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@Deprecated('Use popDisposition instead. ' 'This feature was deprecated after v3.12.0-1.0.pre.')", + "@override" + ] + }, + { + "name": "onPopInvokedWithResult", + "returnType": "void", + "signature": [ + { + "name": "didPop", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "result", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " {@template flutter.widgets.navigator.onPopInvokedWithResult}\n Called after a route pop was handled.\n\n Even when the pop is canceled, for example by a [PopScope] widget, this\n will still be called. The `didPop` parameter indicates whether or not the\n back navigation actually happened successfully.\n {@endtemplate}", + "annotations": [ + "@mustCallSuper" + ] + }, + { + "name": "addScopedWillPopCallback", + "returnType": "void", + "signature": [ + { + "name": "callback", + "description": "", + "type": "Future Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Enables this route to veto attempts by the user to dismiss it.\n\n This callback runs asynchronously and it's possible that it will be called\n after its route has been disposed. The callback should check [State.mounted]\n before doing anything.\n\n A typical application of this callback would be to warn the user about\n unsaved [Form] data if the user attempts to back out of the form. In that\n case, use the [Form.onWillPop] property to register the callback.\n\n See also:\n\n * [WillPopScope], which manages the registration and unregistration\n process automatically.\n * [Form], which provides an `onWillPop` callback that uses this mechanism.\n * [willPop], which runs the callbacks added with this method.\n * [removeScopedWillPopCallback], which removes a callback from the list\n that [willPop] checks.", + "annotations": [ + "@Deprecated('Use registerPopEntry or PopScope instead. ' 'This feature was deprecated after v3.12.0-1.0.pre.')" + ] + }, + { + "name": "removeScopedWillPopCallback", + "returnType": "void", + "signature": [ + { + "name": "callback", + "description": "", + "type": "Future Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove one of the callbacks run by [willPop].\n\n See also:\n\n * [Form], which provides an `onWillPop` callback that uses this mechanism.\n * [addScopedWillPopCallback], which adds callback to the list\n checked by [willPop].", + "annotations": [ + "@Deprecated('Use unregisterPopEntry or PopScope instead. ' 'This feature was deprecated after v3.12.0-1.0.pre.')" + ] + }, + { + "name": "registerPopEntry", + "returnType": "void", + "signature": [ + { + "name": "popEntry", + "description": "", + "type": "PopEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Registers the existence of a [PopEntry] in the route.\n\n [PopEntry] instances registered in this way will have their\n [PopEntry.onPopInvokedWithResult] callbacks called when a route is popped or a pop\n is attempted. They will also be able to block pop operations with\n [PopEntry.canPopNotifier] through this route's [popDisposition] method.\n\n See also:\n\n * [unregisterPopEntry], which performs the opposite operation.", + "annotations": [] + }, + { + "name": "unregisterPopEntry", + "returnType": "void", + "signature": [ + { + "name": "popEntry", + "description": "", + "type": "PopEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Unregisters a [PopEntry] in the route's widget subtree.\n\n See also:\n\n * [registerPopEntry], which performs the opposite operation.", + "annotations": [] + }, + { + "name": "_maybeDispatchNavigationNotification", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "didChangePrevious", + "returnType": "void", + "signature": [ + { + "name": "previousRoute", + "description": "", + "type": "Route?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " This route's previous route has changed to the given new route.\n\n This is called on a route whenever the previous route changes for any\n reason, so long as it is in the history, except for immediately after the\n route itself has been pushed (in which case [didPush] or [didReplace] will\n be called instead).\n\n The `previousRoute` argument will be null if there's no previous route\n (i.e. if [isFirst] is true).", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didChangeNext", + "returnType": "void", + "signature": [ + { + "name": "nextRoute", + "description": "", + "type": "Route?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " This route's next route has changed to the given new route.\n\n This is called on a route whenever the next route changes for any reason,\n so long as it is in the history, including when a route is first added to\n a [Navigator] (e.g. by [Navigator.push]), except for cases when\n [didPopNext] would be called.\n\n The `nextRoute` argument will be null if there's no new next route (i.e.\n if [isCurrent] is true).", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didPopNext", + "returnType": "void", + "signature": [ + { + "name": "nextRoute", + "description": "", + "type": "Route", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " The given route, which was above this one, has been popped off the\n navigator.\n\n This route is now the current route ([isCurrent] is now true), and there\n is no next route.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "changedInternalState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called whenever the internal state of the route has changed.\n\n This should be called whenever [willHandlePopInternally], [didPop],\n [ModalRoute.offstage], or other internal state of the route changes value.\n It is used by [ModalRoute], for example, to report the new information via\n its inherited widget to any children of the route.\n\n See also:\n\n * [changedExternalState], which is called when the [Navigator] has\n updated in some manner that might affect the routes.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "changedExternalState", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called whenever the [Navigator] has updated in some manner that might\n affect routes, to indicate that the route may wish to rebuild as well.\n\n This is called by the [Navigator] whenever the\n [NavigatorState]'s [State.widget] changes (as in [State.didUpdateWidget]),\n for example because the [MaterialApp] has been rebuilt. This\n ensures that routes that directly refer to the state of the\n widget that built the [MaterialApp] will be notified when that\n widget rebuilds, since it would otherwise be difficult to notify\n the routes that state they depend on may have changed.\n\n It is also called whenever the [Navigator]'s dependencies change\n (as in [State.didChangeDependencies]). This allows routes to use the\n [Navigator]'s context ([NavigatorState.context]), for example in\n [ModalRoute.barrierColor], and update accordingly.\n\n The [ModalRoute] subclass overrides this to force the barrier\n overlay to rebuild.\n\n See also:\n\n * [changedInternalState], the equivalent but for changes to the internal\n state of the route.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "_buildModalBarrier", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "buildModalBarrier", + "returnType": "Widget", + "signature": [], + "features": [], + "description": " Build the barrier for this [ModalRoute], subclasses can override\n this method to create their own barrier with customized features such as\n color or accessibility focus size.\n\n See also:\n * [ModalBarrier], which is typically used to build a barrier.\n * [ModalBottomSheetRoute], which overrides this method to build a\n customized barrier.", + "annotations": [] + }, + { + "name": "_buildModalScope", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "createOverlayEntries", + "returnType": "Iterable", + "signature": [], + "features": [ + "abstract" + ], + "description": " Subclasses should override this getter to return the builders for the overlay.", + "annotations": [ + "@factory" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "debugTransitionCompleted", + "returnType": "bool", + "signature": [], + "features": [], + "description": " Returns true if the transition has completed.\n\n It is equivalent to whether the future returned by [completed] has\n completed.\n\n This method only works if assert is enabled. Otherwise it always returns\n false.", + "annotations": [ + "@protected" + ] + }, + { + "name": "createAnimationController", + "returnType": "AnimationController", + "signature": [], + "features": [], + "description": " Called to create the animation controller that will drive the transitions to\n this route from the previous one, and back to the previous route from this\n one.\n\n The returned controller will be disposed by [AnimationController.dispose]\n if the [willDisposeAnimationController] is `true`.", + "annotations": [] + }, + { + "name": "createAnimation", + "returnType": "Animation", + "signature": [], + "features": [], + "description": " Called to create the animation that exposes the current progress of\n the transition controlled by the animation controller created by\n [createAnimationController()].", + "annotations": [] + }, + { + "name": "createSimulation", + "returnType": "Simulation?", + "signature": [ + { + "name": "forward", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Creates the simulation that drives the transition animation for this route.\n\n By default, this method returns null, indicating that the route doesn't\n use simulations, but initiates the transition by calling either\n [AnimationController.forward] or [AnimationController.reverse] with\n [transitionDuration] and the controller's curve.\n\n Subclasses can override this method to return a non-null [Simulation]. In\n this case, the [controller] will instead use the provided simulation to\n animate the transition using [AnimationController.animateWith] or\n [AnimationController.animateBackWith], and the [Simulation.x] is forwarded\n to the value of [animation]. The [controller]'s curve and\n [transitionDuration] are ignored.\n\n This method is invoked each time the navigator pushes or pops this route.\n The `forward` parameter indicates the direction of the transition: true when\n the route is pushed, and false when it is popped.", + "annotations": [] + }, + { + "name": "_createSimulationAndVerify", + "returnType": "Simulation?", + "signature": [ + { + "name": "forward", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_handleStatusChanged", + "returnType": "void", + "signature": [ + { + "name": "status", + "description": "", + "type": "AnimationStatus", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "didReplace", + "returnType": "void", + "signature": [ + { + "name": "oldRoute", + "description": "", + "type": "Route?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called after [install] when the route replaced another in the navigator.\n\n The [didChangeNext] and [didChangePrevious] methods are typically called\n immediately after this method is called.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "didPop", + "returnType": "bool", + "signature": [ + { + "name": "result", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_updateSecondaryAnimation", + "returnType": "void", + "signature": [ + { + "name": "nextRoute", + "description": "", + "type": "Route?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_setSecondaryAnimation", + "returnType": "void", + "signature": [ + { + "name": "animation", + "description": "", + "type": "Animation?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disposed", + "description": "", + "type": "Future?", + "named": false, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "handleStartBackGesture", + "returnType": "void", + "signature": [ + { + "name": "progress", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0.0", + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Handles a predictive back gesture starting.\n\n The `progress` parameter indicates the progress of the gesture from 0.0 to\n 1.0, as in [PredictiveBackEvent.progress].", + "annotations": [] + }, + { + "name": "handleUpdateBackGestureProgress", + "returnType": "void", + "signature": [ + { + "name": "progress", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Handles a predictive back gesture updating as the user drags across the\n screen.\n\n The `progress` parameter indicates the progress of the gesture from 0.0 to\n 1.0, as in [PredictiveBackEvent.progress].", + "annotations": [] + }, + { + "name": "handleCancelBackGesture", + "returnType": "void", + "signature": [], + "features": [ + "abstract" + ], + "description": " Handles a predictive back gesture ending in cancellation.", + "annotations": [] + }, + { + "name": "handleCommitBackGesture", + "returnType": "void", + "signature": [], + "features": [ + "abstract" + ], + "description": " Handles a predictive back gesture ending successfully.", + "annotations": [] + }, + { + "name": "_handleDragEnd", + "returnType": "void", + "signature": [ + { + "name": "animateForward", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Discards any resources used by the object.\n\n This method should not remove its [overlayEntries] from the [Overlay]. The\n object's owner is in charge of doing that.\n\n After this is called, the object is not in a usable state and should be\n discarded.\n\n This method should only be called by the object's owner; typically the\n [Navigator] owns a route and so will call this method when the route is\n removed, after which the route is no longer referenced by the navigator.", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "_updateSettings", + "returnType": "void", + "signature": [ + { + "name": "newSettings", + "description": "", + "type": "RouteSettings", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateRestorationId", + "returnType": "void", + "signature": [ + { + "name": "restorationId", + "description": "", + "type": "String?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "onPopInvoked", + "returnType": "void", + "signature": [ + { + "name": "didPop", + "description": "", + "type": "bool", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called after a route pop was handled.\n\n Even when the pop is canceled, for example by a [PopScope] widget, this\n will still be called. The `didPop` parameter indicates whether or not the\n back navigation actually happened successfully.", + "annotations": [ + "@Deprecated('Override onPopInvokedWithResult instead. ' 'This feature was deprecated after v3.22.0-12.0.pre.')" + ] + }, + { + "name": "didComplete", + "returnType": "void", + "signature": [ + { + "name": "result", + "description": "", + "type": "T?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " The route was popped or is otherwise being removed somewhat gracefully.\n\n This is called by [didPop] and in response to\n [NavigatorState.pushReplacement]. If [didPop] was not called, then the\n [NavigatorState.finalizeRoute] method must be called immediately, and no exit\n animation will run.\n\n The [popped] future is completed by this method. The `result` argument\n specifies the value that this future is completed with, unless it is null,\n in which case [currentResult] is used instead.\n\n This should be called before the pop animation, if any, takes place,\n though in some cases the animation may be driven by the user before the\n route is committed to being popped; this can in particular happen with the\n iOS-style back gesture. See [NavigatorState.didStartUserGesture].", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "addLocalHistoryEntry", + "returnType": "void", + "signature": [ + { + "name": "entry", + "description": "", + "type": "LocalHistoryEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Adds a local history entry to this route.\n\n When asked to pop, if this route has any local history entries, this route\n will handle the pop internally by removing the most recently added local\n history entry.\n\n The given local history entry must not already be part of another local\n history route.\n\n {@tool snippet}\n\n The following example is an app with 2 pages: `HomePage` and `SecondPage`.\n The `HomePage` can navigate to the `SecondPage`.\n\n The `SecondPage` uses a [LocalHistoryEntry] to implement local navigation\n within that page. Pressing 'show rectangle' displays a red rectangle and\n adds a local history entry. At that point, pressing the '< back' button\n pops the latest route, which is the local history entry, and the red\n rectangle disappears. Pressing the '< back' button a second time\n once again pops the latest route, which is the `SecondPage`, itself.\n Therefore, the second press navigates back to the `HomePage`.\n\n ```dart\n class App extends StatelessWidget {\n const App({super.key});\n\n @override\n Widget build(BuildContext context) {\n return MaterialApp(\n initialRoute: '/',\n routes: {\n '/': (BuildContext context) => const HomePage(),\n '/second_page': (BuildContext context) => const SecondPage(),\n },\n );\n }\n }\n\n class HomePage extends StatefulWidget {\n const HomePage({super.key});\n\n @override\n State createState() => _HomePageState();\n }\n\n class _HomePageState extends State {\n @override\n Widget build(BuildContext context) {\n return Scaffold(\n body: Center(\n child: Column(\n mainAxisSize: MainAxisSize.min,\n children: [\n const Text('HomePage'),\n // Press this button to open the SecondPage.\n ElevatedButton(\n child: const Text('Second Page >'),\n onPressed: () {\n Navigator.pushNamed(context, '/second_page');\n },\n ),\n ],\n ),\n ),\n );\n }\n }\n\n class SecondPage extends StatefulWidget {\n const SecondPage({super.key});\n\n @override\n State createState() => _SecondPageState();\n }\n\n class _SecondPageState extends State {\n\n bool _showRectangle = false;\n\n Future _navigateLocallyToShowRectangle() async {\n // This local history entry essentially represents the display of the red\n // rectangle. When this local history entry is removed, we hide the red\n // rectangle.\n setState(() => _showRectangle = true);\n ModalRoute.of(context)?.addLocalHistoryEntry(\n LocalHistoryEntry(\n onRemove: () {\n // Hide the red rectangle.\n setState(() => _showRectangle = false);\n }\n )\n );\n }\n\n @override\n Widget build(BuildContext context) {\n final Widget localNavContent = _showRectangle\n ? Container(\n width: 100.0,\n height: 100.0,\n color: Colors.red,\n )\n : ElevatedButton(\n onPressed: _navigateLocallyToShowRectangle,\n child: const Text('Show Rectangle'),\n );\n\n return Scaffold(\n body: Center(\n child: Column(\n mainAxisAlignment: MainAxisAlignment.center,\n children: [\n localNavContent,\n ElevatedButton(\n child: const Text('< Back'),\n onPressed: () {\n // Pop a route. If this is pressed while the red rectangle is\n // visible then it will pop our local history entry, which\n // will hide the red rectangle. Otherwise, the SecondPage will\n // navigate back to the HomePage.\n Navigator.of(context).pop();\n },\n ),\n ],\n ),\n ),\n );\n }\n }\n ```\n {@end-tool}", + "annotations": [] + }, + { + "name": "removeLocalHistoryEntry", + "returnType": "void", + "signature": [ + { + "name": "entry", + "description": "", + "type": "LocalHistoryEntry", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Remove a local history entry from this route.\n\n The entry's [LocalHistoryEntry.onRemove] callback, if any, will be called\n synchronously.", + "annotations": [] + }, + { + "name": "show", + "returnType": "Future", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "useRootNavigator", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_shouldBeSheet", + "returnType": "bool", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Determines if this route should behave as a sheet based on modalTypeMode and screen size.", + "annotations": [] + }, + { + "name": "_autoShowsSheet", + "returnType": "bool", + "signature": [ + { + "name": "constraints", + "description": "", + "type": "BoxConstraints", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildSheetContent", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Builds content for sheet mode with top gap and rounded corners.", + "annotations": [] + }, + { + "name": "_buildDialogContent", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Builds content for dialog mode with centered positioning.", + "annotations": [] + }, + { + "name": "_wrapContent", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildSheetTransitions", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAnimation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Builds transitions for sheet mode using CupertinoSheetTransition.", + "annotations": [] + }, + { + "name": "_buildDialogTransitions", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "animation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "secondaryAnimation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Builds transitions for dialog mode using fade and scale.", + "annotations": [] + }, + { + "name": "_delegatedDialogSecondaryTransition", + "returnType": "Widget", + "signature": [ + { + "name": "secondaryAnimation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": " Delegated transition for dialog mode that scales down and moves up when covered.", + "annotations": [] + }, + { + "name": "_createDelegatedTransition", + "returnType": "Widget? Function(BuildContext, Animation, Animation, bool, Widget?)", + "signature": [], + "features": [], + "description": " Creates a delegated transition builder that checks if this route is a dialog.", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "PageRoute", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/modal.dart", + "name": "_LdSheetDragGestureDetector", + "isNullSafe": true, + "description": " Gesture detector for drag-to-dismiss on sheet routes.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "route", + "description": "", + "type": "LdModalRoute", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "AnimationController", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "route", + "type": "LdModalRoute", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "controller", + "type": "AnimationController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State<_LdSheetDragGestureDetector>", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/modal.dart", + "name": "_LdSheetDragGestureDetectorState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_dragController", + "type": "_LdSheetDragController?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_recognizer", + "type": "VerticalDragGestureRecognizer", + "description": "", + "features": [ + "late" + ], + "annotations": [] + }, + { + "name": "_kTopGapRatio", + "type": "double", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "_LdSheetDragGestureDetector", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is reinserted into the tree after having been\n removed via [deactivate].\n\n In most cases, after a [State] object has been deactivated, it is _not_\n reinserted into the tree, and its [dispose] method will be called to\n signal that it is ready to be garbage collected.\n\n In some cases, however, after a [State] object has been deactivated, the\n framework will reinsert it into another part of the tree (e.g., if the\n subtree containing this [State] object is grafted from one location in\n the tree to another due to the use of a [GlobalKey]). If that happens,\n the framework will call [activate] to give the [State] object a chance to\n reacquire any resources that it released in [deactivate]. It will then\n also call [build] to give the object a chance to adapt to its new\n location in the tree. If the framework does reinsert this subtree, it\n will do so before the end of the animation frame in which the subtree was\n removed from the tree. For this reason, [State] objects can defer\n releasing most resources until the framework calls their [dispose] method.\n\n The framework does not call this method the first time a [State] object\n is inserted into the tree. Instead, the framework calls [initState] in\n that situation.\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.activate()`.\n\n See also:\n\n * [Element.activate], the corresponding method when an element\n transitions from the \"inactive\" to the \"active\" lifecycle state.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "_handleDragStart", + "returnType": "void", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragStartDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_handleDragUpdate", + "returnType": "void", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragUpdateDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_handleDragEnd", + "returnType": "void", + "signature": [ + { + "name": "details", + "description": "", + "type": "DragEndDetails", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_handleDragCancel", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_handlePointerDown", + "returnType": "void", + "signature": [ + { + "name": "event", + "description": "", + "type": "PointerDownEvent", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/modal/modal.dart", + "name": "_LdSheetDragController", + "isNullSafe": true, + "description": " Controller for managing drag gestures on sheet routes.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "navigator", + "description": "", + "type": "NavigatorState", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "AnimationController", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "getIsActive", + "description": "", + "type": "bool Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "getIsCurrent", + "description": "", + "type": "bool Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "controller", + "type": "AnimationController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "navigator", + "type": "NavigatorState", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "getIsActive", + "type": "bool Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "getIsCurrent", + "type": "bool Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_kMinFlingVelocity", + "type": "double", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "_kDroppedSheetDragAnimationDuration", + "type": "Duration", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "dragUpdate", + "returnType": "void", + "signature": [ + { + "name": "delta", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "dragEnd", + "returnType": "void", + "signature": [ + { + "name": "velocity", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/switch.dart", + "name": "LdSwitch", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "children", + "description": "", + "type": "Map", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "value", + "description": "", + "type": "T", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "disabled", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "label", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.m", + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onChanged", + "description": "", + "type": "dynamic Function(T)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "expand", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "onChanged", + "type": "dynamic Function(T)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "children", + "type": "Map", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "label", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "disabled", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "value", + "type": "T", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "expand", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_buildItem", + "returnType": "Widget", + "signature": [ + { + "name": "theme", + "description": "", + "type": "LdTheme", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_onTap", + "returnType": "void", + "signature": [ + { + "name": "key", + "description": "", + "type": "T", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/retry_indicator.dart", + "name": "LdExceptionRetryIndicator", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "retryState", + "description": "", + "type": "LdRetryState", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "retryState", + "type": "LdRetryState", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "remainingRetryTime", + "type": "Duration", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "totalRetryDelay", + "type": "Duration", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "progress", + "type": "double", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/exception_mapper.dart", + "name": "LdExceptionMapperProvider", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "exceptionMapper", + "description": "", + "type": "LdExceptionMapper?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "exceptionMapper", + "type": "LdExceptionMapper?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/exception_mapper.dart", + "name": "LdExceptionMapper", + "isNullSafe": true, + "description": " A mapper that maps exceptions to LdExceptions that are displayed in the UI.\n You can provide your own exception mapper to handle custom exceptions.\n The default exception mapper will handle common exceptions like network errors.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "localizations", + "description": "", + "type": "LiquidLocalizations", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "onException", + "description": "", + "type": "LdLocalizedException? Function(dynamic, {StackTrace? stackTrace})?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "localizations", + "type": "LiquidLocalizations", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onException", + "type": "LdLocalizedException? Function(dynamic, {StackTrace? stackTrace})?", + "description": " A function that can be used to handle custom exceptions. If the function\n returns a non-null LdException, it will be used instead of the default\n exception mapper. Otherwise, the default exception mapper will be used.\n This function will never be called if the exception is already an LdException.", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "of", + "returnType": "LdExceptionMapper", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "handle", + "returnType": "LdLocalizedException", + "signature": [ + { + "name": "e", + "description": "", + "type": "dynamic", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stackTrace", + "description": "", + "type": "StackTrace?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/exception_more_info_button.dart", + "name": "LdExceptionMoreInfoButton", + "isNullSafe": true, + "description": " LdExceptionMoreInfoButton is a button that will open a dialog with more info", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "error", + "description": "", + "type": "LdLocalizedException?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "error", + "type": "LdLocalizedException?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/exception_dialog.dart", + "name": "LdExceptionDialog", + "isNullSafe": true, + "description": " Renders an LdException in a dialog", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "error", + "description": "", + "type": "LdException", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "primaryButton", + "description": "", + "type": "Widget?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "error", + "type": "LdException", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "primaryButton", + "type": "Widget?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "show", + "returnType": "Future", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/model/exception.dart", + "name": "LdException", + "isNullSafe": true, + "description": " A renderable exception. Has a message, more info, and a type (LdHintType).\n Can also contain a stack trace as well as the flag that the action causing\n the exception can be retried.", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "canRetry", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": false, + "defaultValue": "LdHintType.error", + "annotations": [] + }, + { + "name": "attempt", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stackTrace", + "description": "", + "type": "StackTrace?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "exception", + "description": "", + "type": "dynamic", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + }, + { + "name": "fromDynamic", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "e", + "description": "", + "type": "dynamic", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "stackTrace", + "type": "StackTrace?", + "description": " The stack trace of the exception.", + "features": [ + "final" + ], + "annotations": [ + "@override" + ] + }, + { + "name": "canRetry", + "type": "bool", + "description": " Whether the action causing the exception can be retried.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdHintType", + "description": " The type of the exception. By default, it is [LdHintType.error].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "exception", + "type": "dynamic", + "description": " The actual [Exception] that caused this exception.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "attempt", + "type": "int?", + "description": " The number of attempts that have been made to resolve the exception.\n This can be useful for debugging.", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "copyWith", + "returnType": "LdException", + "signature": [ + { + "name": "message", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "moreInfo", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canRetry", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "attempt", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "exception", + "description": "", + "type": "dynamic", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stackTrace", + "description": "", + "type": "StackTrace?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "localize", + "returnType": "LdLocalizedException", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Error", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/model/exception.dart", + "name": "LdLocalizedException", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "message", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "moreInfo", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canRetry", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType", + "named": true, + "required": false, + "defaultValue": "LdHintType.error", + "annotations": [] + }, + { + "name": "attempt", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stackTrace", + "description": "", + "type": "StackTrace?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "exception", + "description": "", + "type": "dynamic", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + }, + { + "name": "fromException", + "signature": [ + { + "name": "exception", + "description": "", + "type": "LdException", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "message", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "moreInfo", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "canRetry", + "type": "bool", + "description": " Whether the action causing the exception can be retried.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdHintType", + "description": " The type of the exception. By default, it is [LdHintType.error].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "exception", + "type": "dynamic", + "description": " The actual [Exception] that caused this exception.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "attempt", + "type": "int?", + "description": " The number of attempts that have been made to resolve the exception.\n This can be useful for debugging.", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "stackTrace", + "type": "StackTrace?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "message", + "type": "String", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "moreInfo", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "copyWith", + "returnType": "LdException", + "signature": [ + { + "name": "message", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "moreInfo", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canRetry", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdHintType?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "attempt", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "exception", + "description": "", + "type": "dynamic", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stackTrace", + "description": "", + "type": "StackTrace?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "localize", + "returnType": "LdLocalizedException", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdException", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/model/retry_config.dart", + "name": "LdRetryConfig", + "isNullSafe": true, + "description": " Configuration for retry behavior", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "maxAttempts", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "999999", + "annotations": [] + }, + { + "name": "enableAutomaticRetries", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "hideManualRetryButton", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "baseDelay", + "description": "", + "type": "Duration", + "named": true, + "required": false, + "defaultValue": "const Duration(seconds: 3)", + "annotations": [] + }, + { + "name": "useJitter", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "noRetries", + "signature": [], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "unlimitedManualRetries", + "signature": [], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "defaultAutomaticRetries", + "signature": [ + { + "name": "baseDelay", + "description": "", + "type": "Duration", + "named": true, + "required": false, + "defaultValue": "const Duration(seconds: 3)", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "props", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "stringify", + "type": "bool?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "maxAttempts", + "type": "int", + "description": " Maximum number of attempts (including the initial attempt).\n If set to 1, the retry button will be hidden immediately.\n Defaults to 4 (i.e. 3 retries).", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "enableAutomaticRetries", + "type": "bool", + "description": " Whether to enable automatic retries", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "baseDelay", + "type": "Duration", + "description": " Base delay for retries (will be multiplied by exponential backoff)\n Can only be used in combination with [enableAutomaticRetries].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hideManualRetryButton", + "type": "bool", + "description": " Whether to hide the manual retry button.\n Can only be used in combination with [enableAutomaticRetries].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "useJitter", + "type": "bool", + "description": " Whether to add jitter to retry delays\n Can only be used in combination with [enableAutomaticRetries].", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "Equatable", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/exception_view.dart", + "name": "LdExceptionView", + "isNullSafe": true, + "description": " Renders an LdException", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "exception", + "description": "", + "type": "LdLocalizedException?", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "retryController", + "description": "", + "type": "LdRetryController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "retry", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "direction", + "description": "", + "type": "Axis", + "named": true, + "required": false, + "defaultValue": "Axis.vertical", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "fromDynamic", + "signature": [ + { + "name": "error", + "description": "", + "type": "dynamic", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "direction", + "description": "", + "type": "Axis", + "named": true, + "required": false, + "defaultValue": "Axis.vertical", + "annotations": [] + }, + { + "name": "retryController", + "description": "", + "type": "LdRetryController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "retry", + "description": "", + "type": "void Function()?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "stackTrace", + "description": "", + "type": "StackTrace?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "exception", + "type": "LdLocalizedException?", + "description": " The exception to render", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "retryController", + "type": "LdRetryController?", + "description": " The controller for managing retry operations", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "retry", + "type": "void Function()?", + "description": " A callback to retry the action that caused the exception\n If null, the retry button will not be displayed", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "direction", + "type": "Axis", + "description": " The direction of the exception view, either [Axis.vertical] or\n [Axis.horizontal].", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "color", + "returnType": "LdColor", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_createRetryController", + "returnType": "LdRetryController?", + "signature": [], + "features": [], + "description": " Creates a lightweight LdRetryController if a retry callback is provided", + "annotations": [] + }, + { + "name": "_buildRetryButton", + "returnType": "dynamic", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdRetryController?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildRetryIndicator", + "returnType": "dynamic", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdRetryController?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildDialogButton", + "returnType": "dynamic", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "moreInfo", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildHorizontal", + "returnType": "dynamic", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "moreInfo", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdRetryController?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildVertical", + "returnType": "dynamic", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "moreInfo", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "controller", + "description": "", + "type": "LdRetryController?", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/retry_controller.dart", + "name": "LdRetryState", + "isNullSafe": true, + "description": " State object for retry operations", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "attempt", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "remainingRetryTime", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isRetrying", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "canRetry", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "totalRetryDelay", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "attempt", + "type": "int", + "description": " Current attempt number (1-based)", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "remainingRetryTime", + "type": "Duration?", + "description": " Remaining time until next retry", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isRetrying", + "type": "bool", + "description": " Whether retry is in progress", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "canRetry", + "type": "bool", + "description": " Whether retry is enabled", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "totalRetryDelay", + "type": "Duration?", + "description": " The total delay for the current retry", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "copyWith", + "returnType": "LdRetryState", + "signature": [ + { + "name": "attempt", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "remainingRetryTime", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isRetrying", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canRetry", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "totalRetryDelay", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Creates a copy of this state with the given fields replaced", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/exception/retry_controller.dart", + "name": "LdRetryController", + "isNullSafe": true, + "description": " Controller for managing retry operations", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "onRetry", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "config", + "description": "", + "type": "LdRetryConfig", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "config", + "type": "LdRetryConfig", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_stateController", + "type": "StreamController", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_retryTimer", + "type": "Timer?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_state", + "type": "LdRetryState", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_jitter", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onRetry", + "type": "void Function()", + "description": " Function to be called when a retry should be executed", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "stateStream", + "type": "Stream", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "state", + "type": "LdRetryState", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showRetryIndicator", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "showRetryButton", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_setState", + "returnType": "void", + "signature": [ + { + "name": "newState", + "description": "", + "type": "LdRetryState", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Sets the internal state and notifies listeners", + "annotations": [] + }, + { + "name": "_setupRetryTimer", + "returnType": "void", + "signature": [], + "features": [], + "description": " Sets up the retry timer", + "annotations": [] + }, + { + "name": "_getRetryDelay", + "returnType": "Duration", + "signature": [ + { + "name": "attempt", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Calculates the retry delay based on the attempt number", + "annotations": [] + }, + { + "name": "_retryTimerTick", + "returnType": "void", + "signature": [], + "features": [], + "description": " Handles the timer tick for updating remaining time", + "annotations": [] + }, + { + "name": "_executeRetry", + "returnType": "void", + "signature": [], + "features": [], + "description": " Executes the retry operation", + "annotations": [] + }, + { + "name": "handleError", + "returnType": "void", + "signature": [ + { + "name": "canRetry", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called when an error occurs that might be retried", + "annotations": [] + }, + { + "name": "retry", + "returnType": "void", + "signature": [], + "features": [], + "description": " Manually triggers a retry", + "annotations": [] + }, + { + "name": "reset", + "returnType": "void", + "signature": [], + "features": [], + "description": " Resets the retry state", + "annotations": [] + }, + { + "name": "notifyOperationStarted", + "returnType": "void", + "signature": [], + "features": [], + "description": " Notifies the controller that an operation has started", + "annotations": [] + }, + { + "name": "notifyOperationCompleted", + "returnType": "void", + "signature": [], + "features": [], + "description": " Notifies the controller that an operation has completed successfully", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": " Disposes of the controller", + "annotations": [] + }, + { + "name": "toMap", + "returnType": "Map", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/loading.dart", + "name": "LdLoader", + "isNullSafe": true, + "description": " a loading indicator (indeterminate)", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "32", + "annotations": [] + }, + { + "name": "neutral", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "speed", + "description": "", + "type": "Duration", + "named": true, + "required": false, + "defaultValue": "const Duration(seconds: 3)", + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "size", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "speed", + "type": "Duration", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "neutral", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/loading.dart", + "name": "_LdLoaderState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_ticker", + "type": "Ticker?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickerModeNotifier", + "type": "ValueListenable?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_animationController", + "type": "AnimationController", + "description": "", + "features": [ + "late" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "LdLoader", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever the widget configuration changes.\n\n If the parent widget rebuilds and requests that this location in the tree\n update to display a new widget with the same [runtimeType] and\n [Widget.key], the framework will update the [widget] property of this\n [State] object to refer to the new widget and then call this method\n with the previous widget as an argument.\n\n Override this method to respond when the [widget] changes (e.g., to start\n implicit animations).\n\n The framework always calls [build] after calling [didUpdateWidget], which\n means any calls to [setState] in [didUpdateWidget] are redundant.\n\n {@macro flutter.widgets.State.initState}\n\n Implementations of this method should start with a call to the inherited\n method, as in `super.didUpdateWidget(oldWidget)`.\n\n _See the discussion at [Element.rebuild] for more information on when this\n method is called._", + "annotations": [ + "@mustCallSuper", + "@protected" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "createTicker", + "returnType": "Ticker", + "signature": [ + { + "name": "onTick", + "description": "", + "type": "void Function(Duration)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Creates a ticker with the given callback.\n\n The kind of ticker provided depends on the kind of ticker provider.", + "annotations": [ + "@factory" + ] + }, + { + "name": "_updateTicker", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickerModeNotifier", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "SingleTickerProviderStateMixin" + ] + }, + { + "filePath": "lib/src/loading.dart", + "name": "_LoadingPainter", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "animation", + "description": "", + "type": "Animation", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "loaderSize", + "description": "", + "type": "double", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "baseColor", + "description": "", + "type": "Color", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "accentColor", + "description": "", + "type": "Color", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "accentColor2", + "description": "", + "type": "Color", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_repaint", + "type": "Listenable?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "semanticsBuilder", + "type": "List Function(Size)?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "animation", + "type": "Animation", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "loaderSize", + "type": "double", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "baseColor", + "type": "Color", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "accentColor", + "type": "Color", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "accentColor2", + "type": "Color", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "paint", + "returnType": "void", + "signature": [ + { + "name": "canvas", + "description": "", + "type": "Canvas", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "Size", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "shouldRebuildSemantics", + "returnType": "bool", + "signature": [ + { + "name": "oldDelegate", + "description": "", + "type": "CustomPainter", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever a new instance of the custom painter delegate class is\n provided to the [RenderCustomPaint] object, or any time that a new\n [CustomPaint] object is created with a new instance of the custom painter\n delegate class (which amounts to the same thing, because the latter is\n implemented in terms of the former).\n\n If the new instance would cause [semanticsBuilder] to create different\n semantics information, then this method should return true, otherwise it\n should return false.\n\n If the method returns false, then the [semanticsBuilder] call might be\n optimized away.\n\n It's possible that the [semanticsBuilder] will get called even if\n [shouldRebuildSemantics] would return false. For example, it is called\n when the [CustomPaint] is rendered for the very first time, or when the\n box changes its size.\n\n By default this method delegates to [shouldRepaint] under the assumption\n that in most cases semantics change when something new is drawn.", + "annotations": [] + }, + { + "name": "shouldRepaint", + "returnType": "bool", + "signature": [ + { + "name": "oldDelegate", + "description": "", + "type": "CustomPainter", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "hitTest", + "returnType": "bool?", + "signature": [ + { + "name": "position", + "description": "", + "type": "Offset", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Called whenever a hit test is being performed on an object that is using\n this custom paint delegate.\n\n The given point is relative to the same coordinate space as the last\n [paint] call.\n\n The default behavior is to consider all points to be hits for\n background painters, and no points to be hits for foreground painters.\n\n Return true if the given position corresponds to a point on the drawn\n image that should be considered a \"hit\", false if it corresponds to a\n point that should be considered outside the painted image, and null to use\n the default behavior.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "CustomPainter", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/reveal.dart", + "name": "LdReveal", + "isNullSafe": true, + "description": " A utility to reveal some content, with a fade in and collapse effect", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "revealed", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "transformXOffset", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "transformYOffset", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "initialRevealed", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "mass", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "5", + "annotations": [] + }, + { + "name": "onAnimationEnd", + "description": "", + "type": "dynamic Function(BuildContext, List)?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "axes", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {Axis.horizontal, Axis.vertical}", + "annotations": [] + }, + { + "name": "bufferSprings", + "description": "", + "type": "int?", + "named": true, + "required": false, + "defaultValue": "5", + "annotations": [] + }, + { + "name": "springConstant", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "5", + "annotations": [] + }, + { + "name": "dampingCoefficient", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "10", + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + }, + { + "name": "quick", + "signature": [ + { + "name": "revealed", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialRevealed", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "axes", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {Axis.horizontal, Axis.vertical}", + "annotations": [] + }, + { + "name": "transformXOffset", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "transformYOffset", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + }, + { + "name": "slow", + "signature": [ + { + "name": "revealed", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "initialRevealed", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "transformXOffset", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "transformYOffset", + "description": "", + "type": "double", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "axes", + "description": "", + "type": "Set", + "named": true, + "required": false, + "defaultValue": "const {Axis.horizontal, Axis.vertical}", + "annotations": [] + } + ], + "features": [ + "factory" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "revealed", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "transformXOffset", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "transformYOffset", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "springConstant", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "dampingCoefficient", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "mass", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "initialRevealed", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "bufferSprings", + "type": "int?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "axes", + "type": "Set", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onAnimationEnd", + "type": "dynamic Function(BuildContext, List)?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/radius_aware_padding.dart", + "name": "RadiusAwarePadding", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "fallbackSize", + "description": "", + "type": "LdSize", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "innerRadiusSize", + "description": "", + "type": "LdSize", + "named": true, + "required": false, + "defaultValue": "LdSize.s", + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "decoration", + "description": "", + "type": "BoxDecoration?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minPadding", + "description": "", + "type": "EdgeInsets?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "fallbackSize", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "innerRadiusSize", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "minPadding", + "type": "EdgeInsets?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "decoration", + "type": "BoxDecoration?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/notification_portal.dart", + "name": "LdNotificationProvider", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "notifier", + "description": "", + "type": "LdNotificationsController?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugLabel", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "notifier", + "type": "LdNotificationsController?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "debugLabel", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/notification_portal.dart", + "name": "LdNotificationPortal", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "debugLabel", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugLabel", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/notification_portal.dart", + "name": "LdNotificationWidget", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "notification", + "description": "", + "type": "LdNotification", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "removing", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "didConfirm", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "index", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "0", + "annotations": [] + }, + { + "name": "onDismiss", + "description": "", + "type": "void Function()", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "notification", + "type": "LdNotification", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "index", + "type": "int", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "removing", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "didConfirm", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "onDismiss", + "type": "void Function()", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_colorBundle", + "returnType": "LdColor", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_theme", + "returnType": "LdTheme", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_icon", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildAcknowledgeButton", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_buildNotificationBody", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/notification_type.dart", + "name": "LdNotificationType", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "info", + "type": "LdNotificationType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "success", + "type": "LdNotificationType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "warning", + "type": "LdNotificationType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "error", + "type": "LdNotificationType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "loading", + "type": "LdNotificationType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "acknowledge", + "type": "LdNotificationType", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + }, + { + "name": "values", + "type": "List", + "description": "", + "features": [ + "static", + "const" + ], + "annotations": [] + } + ], + "methods": [], + "type": "enum", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/notification.dart", + "name": "LdNotification", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "message", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdNotificationType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "subMessage", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canDismiss", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "removing", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "haptics", + "description": "", + "type": "HapticsType?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "didConfirm", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "duration", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": "const Duration(seconds: 5)", + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "message", + "type": "String", + "description": " Message of the notification", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "subMessage", + "type": "String?", + "description": " Submessage of the notification", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "duration", + "type": "Duration?", + "description": " Duration of the notification. If null the notification will not be dismissed automatically", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": " If the notification is a big notification", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdNotificationType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "haptics", + "type": "HapticsType?", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "removing", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "didConfirm", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "key", + "type": "Key", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "canDismiss", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "showBackdrop", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/notification.dart", + "name": "LdAcknowledgeNotification", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "message", + "description": "", + "type": "String", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "type", + "description": "", + "type": "LdNotificationType", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "subMessage", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "color", + "description": "", + "type": "LdColor?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "canDismiss", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "duration", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": "null", + "annotations": [] + }, + { + "name": "acknowledgeText", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "message", + "type": "String", + "description": " Message of the notification", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "subMessage", + "type": "String?", + "description": " Submessage of the notification", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "duration", + "type": "Duration?", + "description": " Duration of the notification. If null the notification will not be dismissed automatically", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "color", + "type": "LdColor?", + "description": " If the notification is a big notification", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "type", + "type": "LdNotificationType", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "haptics", + "type": "HapticsType?", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "removing", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "didConfirm", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "key", + "type": "Key", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "canDismiss", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "showBackdrop", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "dismissKey", + "type": "Key", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "acknowledgeText", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "LdNotification", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/notifications_controller.dart", + "name": "LdNotificationsController", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "debugLabel", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_count", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_listeners", + "type": "List", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_notificationCallStackDepth", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_reentrantlyRemovedListeners", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugDisposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugCreationDispatched", + "type": "bool", + "description": " If true, the event [ObjectCreated] for this instance was dispatched to\n [FlutterMemoryAllocations].\n\n As [ChangeNotifier] is used as mixin, it does not have constructor,\n so we use [addListener] to dispatch the event.", + "features": [], + "annotations": [] + }, + { + "name": "hasListeners", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "debugLabel", + "type": "String?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_notifications", + "type": "List", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "_disposed", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "notifications", + "type": "List", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "addListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Register a closure to be called when the object notifies its listeners.", + "annotations": [] + }, + { + "name": "_removeAt", + "returnType": "void", + "signature": [ + { + "name": "index", + "description": "", + "type": "int", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "removeListener", + "returnType": "void", + "signature": [ + { + "name": "listener", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Remove a previously registered closure from the list of closures that the\n object notifies.", + "annotations": [] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "notifyListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": " Call all the registered listeners.\n\n Call this method whenever the object changes, to notify any clients the\n object may have changed. Listeners that are added during this iteration\n will not be visited. Listeners that are removed during this iteration will\n not be visited after they are removed.\n\n Exceptions thrown by listeners will be caught and reported using\n [FlutterError.reportError].\n\n This method must not be called after [dispose] has been called.\n\n Surprising behavior can result when reentrantly removing a listener (e.g.\n in response to a notification) that has been registered multiple times.\n See the discussion at [removeListener].", + "annotations": [ + "@protected", + "@visibleForTesting", + "@pragma('vm:notify-debugger-on-exception')" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "_safeNotifyListeners", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "error", + "returnType": "LdNotification", + "signature": [ + { + "name": "message", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "duration", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": "const Duration(seconds: 5)", + "annotations": [] + }, + { + "name": "canDismiss", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "subMessage", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "success", + "returnType": "LdNotification", + "signature": [ + { + "name": "message", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "duration", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": "const Duration(seconds: 5)", + "annotations": [] + }, + { + "name": "canDismiss", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "subMessage", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "warning", + "returnType": "LdNotification", + "signature": [ + { + "name": "message", + "description": "", + "type": "String", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "duration", + "description": "", + "type": "Duration?", + "named": true, + "required": false, + "defaultValue": "const Duration(seconds: 5)", + "annotations": [] + }, + { + "name": "canDismiss", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "true", + "annotations": [] + }, + { + "name": "subMessage", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "addNotification", + "returnType": "LdNotification", + "signature": [ + { + "name": "notification", + "description": "", + "type": "LdNotification", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "onDismissNotification", + "returnType": "Future", + "signature": [ + { + "name": "notification", + "description": "", + "type": "LdNotification", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "clearNotifications", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "of", + "returnType": "LdNotificationsController", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + }, + { + "name": "maybeOf", + "returnType": "LdNotificationsController?", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "ChangeNotifier", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/implicit_blur.dart", + "name": "ImplicitBlur", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "sigma", + "description": "", + "type": "double", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "duration", + "description": "", + "type": "Duration", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "sigma", + "type": "double", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "duration", + "type": "Duration", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "createState", + "returnType": "State", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatefulWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/notifications/implicit_blur.dart", + "name": "_ImplicitBlurState", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "_widget", + "type": "T?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_debugLifecycleState", + "type": "_StateLifecycle", + "description": " The current stage in the lifecycle for this state object.\n\n This field is used by the framework when asserts are enabled to verify\n that [State] objects move through their lifecycle in an orderly fashion.", + "features": [], + "annotations": [] + }, + { + "name": "_element", + "type": "StatefulElement?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "widget", + "type": "T", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "context", + "type": "BuildContext", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "mounted", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_ticker", + "type": "Ticker?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_tickerModeNotifier", + "type": "ValueListenable?", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "_controller", + "type": "AnimationController", + "description": "", + "features": [ + "final", + "late" + ], + "annotations": [] + }, + { + "name": "_tween", + "type": "Tween", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "_debugTypesAreRight", + "returnType": "bool", + "signature": [ + { + "name": "widget", + "description": "", + "type": "Widget", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Verifies that the [State] that was created is one that expects to be\n created for that particular [Widget].", + "annotations": [] + }, + { + "name": "initState", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didUpdateWidget", + "returnType": "void", + "signature": [ + { + "name": "oldWidget", + "description": "", + "type": "ImplicitBlur", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "reassemble", + "returnType": "void", + "signature": [], + "features": [], + "description": " {@macro flutter.widgets.Element.reassemble}\n\n In addition to this method being invoked, it is guaranteed that the\n [build] method will be invoked when a reassemble is signaled. Most\n widgets therefore do not need to do anything in the [reassemble] method.\n\n See also:\n\n * [Element.reassemble]\n * [BindingBase.reassembleApplication]\n * [Image], which uses this to reload images.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "setState", + "returnType": "void", + "signature": [ + { + "name": "fn", + "description": "", + "type": "void Function()", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Notify the framework that the internal state of this object has changed.\n\n Whenever you change the internal state of a [State] object, make the\n change in a function that you pass to [setState]:\n\n ```dart\n setState(() { _myState = newValue; });\n ```\n\n The provided callback is immediately called synchronously. It must not\n return a future (the callback cannot be `async`), since then it would be\n unclear when the state was actually being set.\n\n Calling [setState] notifies the framework that the internal state of this\n object has changed in a way that might impact the user interface in this\n subtree, which causes the framework to schedule a [build] for this [State]\n object.\n\n If you just change the state directly without calling [setState], the\n framework might not schedule a [build] and the user interface for this\n subtree might not be updated to reflect the new state.\n\n Generally it is recommended that the [setState] method only be used to\n wrap the actual changes to the state, not any computation that might be\n associated with the change. For example, here a value used by the [build]\n function is incremented, and then the change is written to disk, but only\n the increment is wrapped in the [setState]:\n\n ```dart\n Future _incrementCounter() async {\n setState(() {\n _counter++;\n });\n Directory directory = await getApplicationDocumentsDirectory(); // from path_provider package\n final String dirName = directory.path;\n await File('$dirName/counter.txt').writeAsString('$_counter');\n }\n ```\n\n Sometimes, the changed state is in some other object not owned by the\n widget [State], but the widget nonetheless needs to be updated to react to\n the new state. This is especially common with [Listenable]s, such as\n [AnimationController]s.\n\n In such cases, it is good practice to leave a comment in the callback\n passed to [setState] that explains what state changed:\n\n ```dart\n void _update() {\n setState(() { /* The animation changed. */ });\n }\n //...\n animation.addListener(_update);\n ```\n\n It is an error to call this method after the framework calls [dispose].\n You can determine whether it is legal to call this method by checking\n whether the [mounted] property is true. That said, it is better practice\n to cancel whatever work might trigger the [setState] rather than merely\n checking for [mounted] before calling [setState], as otherwise CPU cycles\n will be wasted.\n\n ## Design discussion\n\n The original version of this API was a method called `markNeedsBuild`, for\n consistency with [RenderObject.markNeedsLayout],\n [RenderObject.markNeedsPaint], _et al_.\n\n However, early user testing of the Flutter framework revealed that people\n would call `markNeedsBuild()` much more often than necessary. Essentially,\n people used it like a good luck charm, any time they weren't sure if they\n needed to call it, they would call it, just in case.\n\n Naturally, this led to performance issues in applications.\n\n When the API was changed to take a callback instead, this practice was\n greatly reduced. One hypothesis is that prompting developers to actually\n update their state in a callback caused developers to think more carefully\n about what exactly was being updated, and thus improved their understanding\n of the appropriate times to call the method.\n\n In practice, the [setState] method's implementation is trivial: it calls\n the provided callback synchronously, then calls [Element.markNeedsBuild].\n\n ## Performance considerations\n\n There is minimal _direct_ overhead to calling this function, and as it is\n expected to be called at most once per frame, the overhead is irrelevant\n anyway. Nonetheless, it is best to avoid calling this function redundantly\n (e.g. in a tight loop), as it does involve creating a closure and calling\n it. The method is idempotent, there is no benefit to calling it more than\n once per [State] per frame.\n\n The _indirect_ cost of causing this function, however, is high: it causes\n the widget to rebuild, possibly triggering rebuilds for the entire subtree\n rooted at this widget, and further triggering a relayout and repaint of\n the entire corresponding [RenderObject] subtree.\n\n For this reason, this method should only be called when the [build] method\n will, as a result of whatever state change was detected, change its result\n meaningfully.\n\n See also:\n\n * [StatefulWidget], the API documentation for which has a section on\n performance considerations that are relevant here.", + "annotations": [ + "@protected" + ] + }, + { + "name": "deactivate", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when this object is removed from the tree.\n\n The framework calls this method whenever it removes this [State] object\n from the tree. In some cases, the framework will reinsert the [State]\n object into another part of the tree (e.g., if the subtree containing this\n [State] object is grafted from one location in the tree to another due to\n the use of a [GlobalKey]). If that happens, the framework will call\n [activate] to give the [State] object a chance to reacquire any resources\n that it released in [deactivate]. It will then also call [build] to give\n the [State] object a chance to adapt to its new location in the tree. If\n the framework does reinsert this subtree, it will do so before the end of\n the animation frame in which the subtree was removed from the tree. For\n this reason, [State] objects can defer releasing most resources until the\n framework calls their [dispose] method.\n\n Subclasses should override this method to clean up any links between\n this object and other elements in the tree (e.g. if you have provided an\n ancestor with a pointer to a descendant's [RenderObject]).\n\n Implementations of this method should end with a call to the inherited\n method, as in `super.deactivate()`.\n\n See also:\n\n * [dispose], which is called after [deactivate] if the widget is removed\n from the tree permanently.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "activate", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "dispose", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "didChangeDependencies", + "returnType": "void", + "signature": [], + "features": [], + "description": " Called when a dependency of this [State] object changes.\n\n For example, if the previous call to [build] referenced an\n [InheritedWidget] that later changed, the framework would call this\n method to notify this object about the change.\n\n This method is also called immediately after [initState]. It is safe to\n call [BuildContext.dependOnInheritedWidgetOfExactType] from this method.\n\n Subclasses rarely override this method because the framework always\n calls [build] after a dependency changes. Some subclasses do override\n this method because they need to do some expensive work (e.g., network\n fetches) when their dependencies change, and that work would be too\n expensive to do for every build.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "createTicker", + "returnType": "Ticker", + "signature": [ + { + "name": "onTick", + "description": "", + "type": "void Function(Duration)", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "abstract" + ], + "description": " Creates a ticker with the given callback.\n\n The kind of ticker provided depends on the kind of ticker provider.", + "annotations": [ + "@factory" + ] + }, + { + "name": "_updateTicker", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + }, + { + "name": "_updateTickerModeNotifier", + "returnType": "void", + "signature": [], + "features": [], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "State", + "interfaces": [], + "mixins": [ + "SingleTickerProviderStateMixin" + ] + }, + { + "filePath": "lib/src/spacer.dart", + "name": "LdSpacer", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "size", + "description": "", + "type": "LdSize", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "direction", + "description": "", + "type": "Axis?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "size", + "type": "LdSize", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "direction", + "type": "Axis?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/surface.dart", + "name": "LdSurfaceInfo", + "isNullSafe": true, + "description": "", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "isSurface", + "description": "", + "type": "bool", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "annotations": [] + } + ], + "properties": [ + { + "name": "isSurface", + "type": "bool", + "description": "", + "features": [], + "annotations": [] + } + ], + "methods": [ + { + "name": "of", + "returnType": "LdSurfaceInfo", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "listen", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + } + ], + "features": [ + "static" + ], + "description": "", + "annotations": [] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": null, + "interfaces": [], + "mixins": [] + }, + { + "filePath": "lib/src/surface.dart", + "name": "LdAutoBackground", + "isNullSafe": true, + "description": " A widget that will change its background color based on the parent surface", + "constructors": [ + { + "name": "new", + "signature": [ + { + "name": "key", + "description": "", + "type": "Key?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "child", + "description": "", + "type": "Widget", + "named": true, + "required": true, + "defaultValue": null, + "annotations": [] + }, + { + "name": "invert", + "description": "", + "type": "bool", + "named": true, + "required": false, + "defaultValue": "false", + "annotations": [] + }, + { + "name": "borderRadius", + "description": "", + "type": "BorderRadius?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "isSurface", + "description": "", + "type": "bool?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [ + "const" + ], + "annotations": [] + } + ], + "properties": [ + { + "name": "key", + "type": "Key?", + "description": " Controls how one widget replaces another widget in the tree.\n\n If the [runtimeType] and [key] properties of the two widgets are\n [operator==], respectively, then the new widget replaces the old widget by\n updating the underlying element (i.e., by calling [Element.update] with the\n new widget). Otherwise, the old element is removed from the tree, the new\n widget is inflated into an element, and the new element is inserted into the\n tree.\n\n In addition, using a [GlobalKey] as the widget's [key] allows the element\n to be moved around the tree (changing parent) without losing state. When a\n new widget is found (its key and type do not match a previous widget in\n the same location), but there was a widget with that same global key\n elsewhere in the tree in the previous frame, then that widget's element is\n moved to the new location.\n\n Generally, a widget that is the only child of another widget does not need\n an explicit key.\n\n See also:\n\n * The discussions at [Key] and [GlobalKey].", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "hashCode", + "type": "int", + "description": "", + "features": [], + "annotations": [] + }, + { + "name": "child", + "type": "Widget", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "invert", + "type": "bool", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "isSurface", + "type": "bool?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + }, + { + "name": "borderRadius", + "type": "BorderRadius?", + "description": "", + "features": [ + "final" + ], + "annotations": [] + } + ], + "methods": [ + { + "name": "createElement", + "returnType": "Element", + "signature": [], + "features": [ + "abstract" + ], + "description": " Inflates this configuration to a concrete instance.\n\n A given widget can be included in the tree zero or more times. In particular\n a given widget can be placed in the tree multiple times. Each time a widget\n is placed in the tree, it is inflated into an [Element], which means a\n widget that is incorporated into the tree multiple times will be inflated\n multiple times.", + "annotations": [ + "@protected", + "@factory" + ] + }, + { + "name": "build", + "returnType": "Widget", + "signature": [ + { + "name": "context", + "description": "", + "type": "BuildContext", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + }, + { + "name": "toStringShort", + "returnType": "String", + "signature": [], + "features": [], + "description": " A brief description of this object, usually just the [runtimeType] and the\n [hashCode].\n\n See also:\n\n * [toString], for a detailed description of the object.", + "annotations": [] + }, + { + "name": "debugFillProperties", + "returnType": "void", + "signature": [ + { + "name": "properties", + "description": "", + "type": "DiagnosticPropertiesBuilder", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Add additional properties associated with the node.\n\n {@youtube 560 315 https://www.youtube.com/watch?v=DnC7eT-vh1k}\n\n Use the most specific [DiagnosticsProperty] existing subclass to describe\n each property instead of the [DiagnosticsProperty] base class. There are\n only a small number of [DiagnosticsProperty] subclasses each covering a\n common use case. Consider what values a property is relevant for users\n debugging as users debugging large trees are overloaded with information.\n Common named parameters in [DiagnosticsNode] subclasses help filter when\n and how properties are displayed.\n\n `defaultValue`, `showName`, `showSeparator`, and `level` keep string\n representations of diagnostics terse and hide properties when they are not\n very useful.\n\n * Use `defaultValue` any time the default value of a property is\n uninteresting. For example, specify a default value of null any time\n a property being null does not indicate an error.\n * Avoid specifying the `level` parameter unless the result you want\n cannot be achieved by using the `defaultValue` parameter or using\n the [ObjectFlagProperty] class to conditionally display the property\n as a flag.\n * Specify `showName` and `showSeparator` in rare cases where the string\n output would look clumsy if they were not set.\n ```dart\n DiagnosticsProperty('child(3, 4)', null, ifNull: 'is null', showSeparator: false).toString()\n ```\n Shows using `showSeparator` to get output `child(3, 4) is null` which\n is more polished than `child(3, 4): is null`.\n ```dart\n DiagnosticsProperty('icon', icon, ifNull: '', showName: false).toString()\n ```\n Shows using `showName` to omit the property name as in this context the\n property name does not add useful information.\n\n `ifNull`, `ifEmpty`, `unit`, and `tooltip` make property\n descriptions clearer. The examples in the code sample below illustrate\n good uses of all of these parameters.\n\n ## DiagnosticsProperty subclasses for primitive types\n\n * [StringProperty], which supports automatically enclosing a [String]\n value in quotes.\n * [DoubleProperty], which supports specifying a unit of measurement for\n a [double] value.\n * [PercentProperty], which clamps a [double] to between 0 and 1 and\n formats it as a percentage.\n * [IntProperty], which supports specifying a unit of measurement for an\n [int] value.\n * [FlagProperty], which formats a [bool] value as one or more flags.\n Depending on the use case it is better to format a bool as\n `DiagnosticsProperty` instead of using [FlagProperty] as the\n output is more verbose but unambiguous.\n\n ## Other important [DiagnosticsProperty] variants\n\n * [EnumProperty], which provides terse descriptions of enum values\n working around limitations of the `toString` implementation for Dart\n enum types.\n * [IterableProperty], which handles iterable values with display\n customizable depending on the [DiagnosticsTreeStyle] used.\n * [ObjectFlagProperty], which provides terse descriptions of whether a\n property value is present or not. For example, whether an `onClick`\n callback is specified or an animation is in progress.\n * [ColorProperty], which must be used if the property value is\n a [Color] or one of its subclasses.\n * [IconDataProperty], which must be used if the property value\n is of type [IconData].\n\n If none of these subclasses apply, use the [DiagnosticsProperty]\n constructor or in rare cases create your own [DiagnosticsProperty]\n subclass as in the case for [TransformProperty] which handles [Matrix4]\n that represent transforms. Generally any property value with a good\n `toString` method implementation works fine using [DiagnosticsProperty]\n directly.\n\n {@tool snippet}\n\n This example shows best practices for implementing [debugFillProperties]\n illustrating use of all common [DiagnosticsProperty] subclasses and all\n common [DiagnosticsProperty] parameters.\n\n ```dart\n class ExampleObject extends ExampleSuperclass {\n\n // ...various members and properties...\n\n @override\n void debugFillProperties(DiagnosticPropertiesBuilder properties) {\n // Always add properties from the base class first.\n super.debugFillProperties(properties);\n\n // Omit the property name 'message' when displaying this String property\n // as it would just add visual noise.\n properties.add(StringProperty('message', message, showName: false));\n\n properties.add(DoubleProperty('stepWidth', stepWidth));\n\n // A scale of 1.0 does nothing so should be hidden.\n properties.add(DoubleProperty('scale', scale, defaultValue: 1.0));\n\n // If the hitTestExtent matches the paintExtent, it is just set to its\n // default value so is not relevant.\n properties.add(DoubleProperty('hitTestExtent', hitTestExtent, defaultValue: paintExtent));\n\n // maxWidth of double.infinity indicates the width is unconstrained and\n // so maxWidth has no impact.\n properties.add(DoubleProperty('maxWidth', maxWidth, defaultValue: double.infinity));\n\n // Progress is a value between 0 and 1 or null. Showing it as a\n // percentage makes the meaning clear enough that the name can be\n // hidden.\n properties.add(PercentProperty(\n 'progress',\n progress,\n showName: false,\n ifNull: '',\n ));\n\n // Most text fields have maxLines set to 1.\n properties.add(IntProperty('maxLines', maxLines, defaultValue: 1));\n\n // Specify the unit as otherwise it would be unclear that time is in\n // milliseconds.\n properties.add(IntProperty('duration', duration.inMilliseconds, unit: 'ms'));\n\n // Tooltip is used instead of unit for this case as a unit should be a\n // terse description appropriate to display directly after a number\n // without a space.\n properties.add(DoubleProperty(\n 'device pixel ratio',\n devicePixelRatio,\n tooltip: 'physical pixels per logical pixel',\n ));\n\n // Displaying the depth value would be distracting. Instead only display\n // if the depth value is missing.\n properties.add(ObjectFlagProperty('depth', depth, ifNull: 'no depth'));\n\n // bool flag that is only shown when the value is true.\n properties.add(FlagProperty('using primary controller', value: primary));\n\n properties.add(FlagProperty(\n 'isCurrent',\n value: isCurrent,\n ifTrue: 'active',\n ifFalse: 'inactive',\n ));\n\n properties.add(DiagnosticsProperty('keepAlive', keepAlive));\n\n // FlagProperty could have also been used in this case.\n // This option results in the text \"obscureText: true\" instead\n // of \"obscureText\" which is a bit more verbose but a bit clearer.\n properties.add(DiagnosticsProperty('obscureText', obscureText, defaultValue: false));\n\n properties.add(EnumProperty('textAlign', textAlign, defaultValue: null));\n properties.add(EnumProperty('repeat', repeat, defaultValue: ImageRepeat.noRepeat));\n\n // Warn users when the widget is missing but do not show the value.\n properties.add(ObjectFlagProperty('widget', widget, ifNull: 'no widget'));\n\n properties.add(IterableProperty(\n 'boxShadow',\n boxShadow,\n defaultValue: null,\n style: style,\n ));\n\n // Getting the value of size throws an exception unless hasSize is true.\n properties.add(DiagnosticsProperty.lazy(\n 'size',\n () => size,\n description: '${ hasSize ? size : \"MISSING\" }',\n ));\n\n // If the `toString` method for the property value does not provide a\n // good terse description, write a DiagnosticsProperty subclass as in\n // the case of TransformProperty which displays a nice debugging view\n // of a Matrix4 that represents a transform.\n properties.add(TransformProperty('transform', transform));\n\n // If the value class has a good `toString` method, use\n // DiagnosticsProperty. Specifying the value type ensures\n // that debugging tools always know the type of the field and so can\n // provide the right UI affordances. For example, in this case even\n // if color is null, a debugging tool still knows the value is a Color\n // and can display relevant color related UI.\n properties.add(DiagnosticsProperty('color', color));\n\n // Use a custom description to generate a more terse summary than the\n // `toString` method on the map class.\n properties.add(DiagnosticsProperty>(\n 'handles',\n handles,\n description: handles != null\n ? '${handles!.length} active client${ handles!.length == 1 ? \"\" : \"s\" }'\n : null,\n ifNull: 'no notifications ever received',\n showName: false,\n ));\n }\n }\n ```\n {@end-tool}\n\n Used by [toDiagnosticsNode] and [toString].\n\n Do not add values that have lifetime shorter than the object.", + "annotations": [ + "@protected", + "@mustCallSuper" + ] + }, + { + "name": "==", + "returnType": "bool", + "signature": [ + { + "name": "other", + "description": "", + "type": "Object", + "named": false, + "required": true, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override", + "@nonVirtual" + ] + }, + { + "name": "toStringShallow", + "returnType": "String", + "signature": [ + { + "name": "joiner", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "', '", + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + } + ], + "features": [], + "description": " Returns a one-line detailed description of the object.\n\n This description is often somewhat long. This includes the same\n information given by [toStringDeep], but does not recurse to any children.\n\n `joiner` specifies the string which is place between each part obtained\n from [debugFillProperties]. Passing a string such as `'\\n '` will result\n in a multiline string that indents the properties of the object below its\n name (as per [toString]).\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n See also:\n\n * [toString], for a brief description of the object.\n * [toStringDeep], for a description of the subtree rooted at this object.", + "annotations": [] + }, + { + "name": "toStringDeep", + "returnType": "String", + "signature": [ + { + "name": "prefixLineOne", + "description": "", + "type": "String", + "named": true, + "required": false, + "defaultValue": "''", + "annotations": [] + }, + { + "name": "prefixOtherLines", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.debug", + "annotations": [] + }, + { + "name": "wrapWidth", + "description": "", + "type": "int", + "named": true, + "required": false, + "defaultValue": "65", + "annotations": [] + } + ], + "features": [], + "description": " Returns a string representation of this node and its descendants.\n\n `prefixLineOne` will be added to the front of the first line of the\n output. `prefixOtherLines` will be added to the front of each other line.\n If `prefixOtherLines` is null, the `prefixLineOne` is used for every line.\n By default, there is no prefix.\n\n `minLevel` specifies the minimum [DiagnosticLevel] for properties included\n in the output.\n\n `wrapWidth` specifies the column number where word wrapping will be\n applied.\n\n The [toStringDeep] method takes other arguments, but those are intended\n for internal use when recursing to the descendants, and so can be ignored.\n\n See also:\n\n * [toString], for a brief description of the object but not its children.\n * [toStringShallow], for a detailed description of the object but not its\n children.", + "annotations": [] + }, + { + "name": "toDiagnosticsNode", + "returnType": "DiagnosticsNode", + "signature": [ + { + "name": "name", + "description": "", + "type": "String?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + }, + { + "name": "style", + "description": "", + "type": "DiagnosticsTreeStyle?", + "named": true, + "required": false, + "defaultValue": null, + "annotations": [] + } + ], + "features": [], + "description": " Returns a debug representation of the object that is used by debugging\n tools and by [DiagnosticsNode.toStringDeep].\n\n Leave [name] as null if there is not a meaningful description of the\n relationship between the this node and its parent.\n\n Typically the [style] argument is only specified to indicate an atypical\n relationship between the parent and the node. For example, pass\n [DiagnosticsTreeStyle.offstage] to indicate that a node is offstage.", + "annotations": [] + }, + { + "name": "debugDescribeChildren", + "returnType": "List", + "signature": [], + "features": [], + "description": " Returns a list of [DiagnosticsNode] objects describing this node's\n children.\n\n Children that are offstage should be added with `style` set to\n [DiagnosticsTreeStyle.offstage] to indicate that they are offstage.\n\n The list must not contain any null entries. If there are explicit null\n children to report, consider [DiagnosticsNode.message] or\n [DiagnosticsProperty] as possible [DiagnosticsNode] objects to\n provide.\n\n Used by [toStringDeep], [toDiagnosticsNode] and [toStringShallow].\n\n See also:\n\n * [RenderTable.debugDescribeChildren], which provides high quality custom\n descriptions for its child nodes.", + "annotations": [ + "@protected" + ] + }, + { + "name": "toString", + "returnType": "String", + "signature": [ + { + "name": "minLevel", + "description": "", + "type": "DiagnosticLevel", + "named": true, + "required": false, + "defaultValue": "DiagnosticLevel.info", + "annotations": [] + } + ], + "features": [], + "description": "", + "annotations": [ + "@override" + ] + } + ], + "type": "class", + "aliasedType": null, + "annotations": [], + "superClass": "StatelessWidget", + "interfaces": [], + "mixins": [] + } +] \ No newline at end of file diff --git a/apps/liquid-gen/pubspec.yaml b/apps/liquid-gen/pubspec.yaml new file mode 100644 index 00000000..b9b38230 --- /dev/null +++ b/apps/liquid-gen/pubspec.yaml @@ -0,0 +1,50 @@ +name: liquid_gen +description: AI-powered UI screen generator for Liquid Flutter. + +version: 1.0.0+1 + +environment: + sdk: ">=3.10.0 <4.0.0" + +resolution: workspace +publish_to: "none" + +dependencies: + flutter: + sdk: flutter + liquid_flutter: + path: ../../packages/liquid_flutter + liquid_flutter_emd_theme: + path: ../../packages/liquid_flutter_emd_theme + liquid_flutter_window_utils: + path: ../../packages/liquid_flutter_window_utils + liquid_flutter_test_utils: + path: ../../packages/liquid_flutter_test_utils + provider: ^6.0.2 + go_router: ^17.0.1 + genui: + genui_google_generative_ai: + json_schema_builder: + lucide_icons_flutter: ^3.1.9 + json_annotation: ^4.9.0 + flutter_secure_storage: ^9.0.0 + logger: ^2.6.2 + +dev_dependencies: + flutter_test: + sdk: flutter + flutter_lints: ^6.0.0 + +flutter: + uses-material-design: true + + assets: + - ../../packages/liquid_flutter/api_guard/api.json + + fonts: + - family: Lato + fonts: + - asset: packages/liquid_flutter/fonts/Lato-Regular.ttf + weight: 500 + - asset: packages/liquid_flutter/fonts/Lato-Bold.ttf + weight: 800 diff --git a/apps/liquid-gen/test_output/widget_tree_schema.json b/apps/liquid-gen/test_output/widget_tree_schema.json new file mode 100644 index 00000000..c40b1272 --- /dev/null +++ b/apps/liquid-gen/test_output/widget_tree_schema.json @@ -0,0 +1,11481 @@ +{ + "type": "object", + "additionalProperties": false, + "properties": { + "widgetTree": { + "oneOf": [ + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdAccordion", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "itemCount": { + "type": "number" + }, + "allowMultipleOpen": { + "type": "boolean" + }, + "childPadding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "size": { + "type": [ + "string", + "null" + ], + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "headerPadding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "initialOpenIndex": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "wrapActiveInCard": { + "type": "boolean" + }, + "flatCard": { + "type": "boolean" + }, + "speed": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "shrinkWrap": { + "type": "boolean" + } + }, + "required": [ + "itemCount" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdAppBar", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "actions": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "addContainer": { + "type": "boolean" + }, + "attachedMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "autoAttachToKeyboard": { + "type": "boolean" + }, + "backgroundColor": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + }, + "backgroundMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "borderMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "bottom": { + "$ref": "#/$defs/widgetNode" + }, + "debugName": { + "type": [ + "string", + "null" + ] + }, + "implyCloseModalButton": { + "type": "boolean" + }, + "implyLeading": { + "type": [ + "boolean", + "null" + ] + }, + "avoidViewInsets": { + "type": "boolean" + }, + "leading": { + "$ref": "#/$defs/widgetNode" + }, + "order": { + "type": "number" + }, + "positionMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "scrollBehavior": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "searchConfig": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "shadowMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "showWindowControls": { + "type": "boolean" + }, + "title": { + "$ref": "#/$defs/widgetNode" + }, + "trailing": { + "$ref": "#/$defs/widgetNode" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdAutoSpace", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "defaultSpacing": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "crossAxisAlignment": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "animate": { + "type": "boolean" + } + }, + "required": [ + "children" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdAvatar", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "circular": { + "type": [ + "boolean", + "null" + ] + }, + "size": { + "type": [ + "string", + "null" + ], + "enum": [ + "xs", + "s", + "m", + "l" + ] + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdBadge", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "symmetric": { + "type": "boolean" + }, + "maxLines": { + "type": [ + "number", + "null" + ] + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdBreadcrumb", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + } + }, + "required": [ + "children" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdBundle", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + } + }, + "required": [ + "children" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdButton", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "autoLoading": { + "type": [ + "boolean", + "null" + ] + }, + "borderRadius": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "topLeft": { + "type": [ + "number", + "null" + ] + }, + "topRight": { + "type": [ + "number", + "null" + ] + }, + "bottomLeft": { + "type": [ + "number", + "null" + ] + }, + "bottomRight": { + "type": [ + "number", + "null" + ] + } + } + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "active": { + "type": [ + "boolean", + "null" + ] + }, + "width": { + "type": [ + "number", + "null" + ] + }, + "disabled": { + "type": [ + "boolean", + "null" + ] + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "autoFocus": { + "type": "boolean" + }, + "alignment": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "leading": { + "$ref": "#/$defs/widgetNode" + }, + "circular": { + "type": [ + "boolean", + "null" + ] + }, + "loading": { + "type": "boolean" + }, + "loadingText": { + "type": [ + "string", + "null" + ] + }, + "errorText": { + "type": [ + "string", + "null" + ] + }, + "mode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "progress": { + "type": [ + "number", + "null" + ] + }, + "size": { + "type": [ + "string", + "null" + ], + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "trailing": { + "$ref": "#/$defs/widgetNode" + }, + "disableSqueeze": { + "type": [ + "boolean", + "null" + ] + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdCard", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "header": { + "$ref": "#/$defs/widgetNode" + }, + "footer": { + "$ref": "#/$defs/widgetNode" + }, + "flat": { + "type": "boolean" + }, + "expandChild": { + "type": "boolean" + }, + "padding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdCheckbox", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "label": { + "type": [ + "string", + "null" + ] + }, + "checked": { + "type": [ + "boolean", + "null" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": [ + "string", + "null" + ], + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "disabled": { + "type": [ + "boolean", + "null" + ] + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdContainer", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "maxWidth": { + "type": [ + "number", + "null" + ] + }, + "padding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdDatePicker", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "label": { + "type": [ + "string", + "null" + ] + }, + "value": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "minDate": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "maxDate": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "displayFormat": { + "type": "string" + }, + "buttonMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "disabled": { + "type": "boolean" + }, + "useRootNavigator": { + "type": "boolean" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdDivider", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "height": { + "type": [ + "number", + "null" + ] + }, + "insetForLeading": { + "type": "boolean" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdExceptionView", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "exception": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "retryController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "direction": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "exception" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdHint", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "crossAxisAlignment": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "type" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdInput", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "hint": { + "type": "string" + }, + "controller": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "obscureText": { + "type": "boolean" + }, + "leading": { + "$ref": "#/$defs/widgetNode" + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "minLines": { + "type": [ + "number", + "null" + ] + }, + "autofocus": { + "type": "boolean" + }, + "showClear": { + "type": "boolean" + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "allowTapOutside": { + "type": "boolean" + }, + "valid": { + "type": "boolean" + }, + "loading": { + "type": "boolean" + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "autofillHints": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "disabled": { + "type": "boolean" + }, + "textInputAction": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "keyboardType": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "trailingHint": { + "$ref": "#/$defs/widgetNode" + } + }, + "required": [ + "hint" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdList", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "paginator": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "assumedItemHeight": { + "type": [ + "number", + "null" + ] + }, + "footer": { + "$ref": "#/$defs/widgetNode" + }, + "header": { + "$ref": "#/$defs/widgetNode" + }, + "padding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "physics": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "primary": { + "type": [ + "boolean", + "null" + ] + }, + "retryConfig": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "scrollController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "shrinkWrap": { + "type": [ + "boolean", + "null" + ] + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdListEmpty", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": [ + "string", + "null" + ] + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdListItem", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "active": { + "type": [ + "boolean", + "null" + ] + }, + "borderRadius": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "topLeft": { + "type": [ + "number", + "null" + ] + }, + "topRight": { + "type": [ + "number", + "null" + ] + }, + "bottomLeft": { + "type": [ + "number", + "null" + ] + }, + "bottomRight": { + "type": [ + "number", + "null" + ] + } + } + }, + "disabled": { + "type": [ + "boolean", + "null" + ] + }, + "isSelected": { + "type": [ + "boolean", + "null" + ] + }, + "leading": { + "$ref": "#/$defs/widgetNode" + }, + "padding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "selectDisabled": { + "type": "boolean" + }, + "subContent": { + "$ref": "#/$defs/widgetNode" + }, + "subtitle": { + "$ref": "#/$defs/widgetNode" + }, + "title": { + "$ref": "#/$defs/widgetNode" + }, + "tradeLeadingForSelectionControl": { + "type": "boolean" + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "trailing": { + "$ref": "#/$defs/widgetNode" + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "width": { + "type": [ + "number", + "null" + ] + }, + "selectionControl": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdListLoading", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": {} + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdLoading", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": {} + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdNotification", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "message": { + "type": "string" + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "subMessage": { + "type": [ + "string", + "null" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "canDismiss": { + "type": "boolean" + }, + "removing": { + "type": "boolean" + }, + "haptics": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "didConfirm": { + "type": "boolean" + }, + "duration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "message", + "type" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdRadio", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "label": { + "type": [ + "string", + "null" + ] + }, + "checked": { + "type": "boolean" + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "disabled": { + "type": "boolean" + } + }, + "required": [ + "checked" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdScaffold", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "body": { + "$ref": "#/$defs/widgetNode" + }, + "appBars": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "debugName": { + "type": [ + "string", + "null" + ] + }, + "toggleDrawerShortcut": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "extendBodyBehindAppBar": { + "type": "boolean" + }, + "backgroundColor": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + }, + "drawer": { + "$ref": "#/$defs/widgetNode" + }, + "drawerWidth": { + "type": "number" + }, + "reflowBreakpoint": { + "type": [ + "number", + "null" + ] + }, + "resizeToAvoidBottomInset": { + "type": [ + "boolean", + "null" + ] + }, + "searchController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "primaryScrollController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "body" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdScaffoldBody", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "minimumPadding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "slivers": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "scrollController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "backgroundColor": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + }, + "autoSpaceChildren": { + "type": "boolean" + }, + "addContainer": { + "type": "boolean" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdSelect", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "items": { + "type": "array", + "items": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "placeholder": { + "type": [ + "string", + "null" + ] + }, + "disabled": { + "type": "boolean" + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "value": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "valid": { + "type": "boolean" + }, + "onSurface": { + "type": "boolean" + } + }, + "required": [ + "items" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdSheet", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": {} + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdSlider", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "hint": { + "type": [ + "string", + "null" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "disabled": { + "type": "boolean" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdSwitch", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "value": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "disabled": { + "type": "boolean" + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "expand": { + "type": "boolean" + } + }, + "required": [ + "children", + "value" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdTable", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "columns": { + "type": "array", + "items": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "rows": { + "type": "array", + "items": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "selectedRows": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "header": { + "$ref": "#/$defs/widgetNode" + }, + "allowSort": { + "type": "boolean" + }, + "rowCount": { + "type": "number" + }, + "density": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "columns", + "rows", + "rowCount" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdTag", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.caption", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.h", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.hl", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.hs", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.hxs", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.l", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.ll", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.ls", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.lxs", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.p", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.pl", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.ps", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.pxs", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdTimePicker", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "useRootNavigator": { + "type": "boolean" + }, + "disabled": { + "type": "boolean" + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "buttonMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "value": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "minutePrecision": { + "type": "number" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + } + ], + "description": "A widget node. Must match one of the widget type schemas." + } + }, + "required": [ + "widgetTree" + ], + "$defs": { + "widgetNode": { + "oneOf": [ + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdAccordion", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "itemCount": { + "type": "number" + }, + "allowMultipleOpen": { + "type": "boolean" + }, + "childPadding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "size": { + "type": [ + "string", + "null" + ], + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "headerPadding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "initialOpenIndex": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "wrapActiveInCard": { + "type": "boolean" + }, + "flatCard": { + "type": "boolean" + }, + "speed": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "shrinkWrap": { + "type": "boolean" + } + }, + "required": [ + "itemCount" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdAppBar", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "actions": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "addContainer": { + "type": "boolean" + }, + "attachedMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "autoAttachToKeyboard": { + "type": "boolean" + }, + "backgroundColor": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + }, + "backgroundMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "borderMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "bottom": { + "$ref": "#/$defs/widgetNode" + }, + "debugName": { + "type": [ + "string", + "null" + ] + }, + "implyCloseModalButton": { + "type": "boolean" + }, + "implyLeading": { + "type": [ + "boolean", + "null" + ] + }, + "avoidViewInsets": { + "type": "boolean" + }, + "leading": { + "$ref": "#/$defs/widgetNode" + }, + "order": { + "type": "number" + }, + "positionMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "scrollBehavior": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "searchConfig": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "shadowMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "showWindowControls": { + "type": "boolean" + }, + "title": { + "$ref": "#/$defs/widgetNode" + }, + "trailing": { + "$ref": "#/$defs/widgetNode" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdAutoSpace", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "defaultSpacing": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "crossAxisAlignment": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "animate": { + "type": "boolean" + } + }, + "required": [ + "children" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdAvatar", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "circular": { + "type": [ + "boolean", + "null" + ] + }, + "size": { + "type": [ + "string", + "null" + ], + "enum": [ + "xs", + "s", + "m", + "l" + ] + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdBadge", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "symmetric": { + "type": "boolean" + }, + "maxLines": { + "type": [ + "number", + "null" + ] + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdBreadcrumb", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + } + }, + "required": [ + "children" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdBundle", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + } + }, + "required": [ + "children" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdButton", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "autoLoading": { + "type": [ + "boolean", + "null" + ] + }, + "borderRadius": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "topLeft": { + "type": [ + "number", + "null" + ] + }, + "topRight": { + "type": [ + "number", + "null" + ] + }, + "bottomLeft": { + "type": [ + "number", + "null" + ] + }, + "bottomRight": { + "type": [ + "number", + "null" + ] + } + } + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "active": { + "type": [ + "boolean", + "null" + ] + }, + "width": { + "type": [ + "number", + "null" + ] + }, + "disabled": { + "type": [ + "boolean", + "null" + ] + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "autoFocus": { + "type": "boolean" + }, + "alignment": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "leading": { + "$ref": "#/$defs/widgetNode" + }, + "circular": { + "type": [ + "boolean", + "null" + ] + }, + "loading": { + "type": "boolean" + }, + "loadingText": { + "type": [ + "string", + "null" + ] + }, + "errorText": { + "type": [ + "string", + "null" + ] + }, + "mode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "progress": { + "type": [ + "number", + "null" + ] + }, + "size": { + "type": [ + "string", + "null" + ], + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "trailing": { + "$ref": "#/$defs/widgetNode" + }, + "disableSqueeze": { + "type": [ + "boolean", + "null" + ] + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdCard", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "header": { + "$ref": "#/$defs/widgetNode" + }, + "footer": { + "$ref": "#/$defs/widgetNode" + }, + "flat": { + "type": "boolean" + }, + "expandChild": { + "type": "boolean" + }, + "padding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdCheckbox", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "label": { + "type": [ + "string", + "null" + ] + }, + "checked": { + "type": [ + "boolean", + "null" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": [ + "string", + "null" + ], + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "disabled": { + "type": [ + "boolean", + "null" + ] + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdContainer", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "maxWidth": { + "type": [ + "number", + "null" + ] + }, + "padding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdDatePicker", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "label": { + "type": [ + "string", + "null" + ] + }, + "value": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "minDate": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "maxDate": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "displayFormat": { + "type": "string" + }, + "buttonMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "disabled": { + "type": "boolean" + }, + "useRootNavigator": { + "type": "boolean" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdDivider", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "height": { + "type": [ + "number", + "null" + ] + }, + "insetForLeading": { + "type": "boolean" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdExceptionView", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "exception": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "retryController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "direction": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "exception" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdHint", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "crossAxisAlignment": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "type" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdInput", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "hint": { + "type": "string" + }, + "controller": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "obscureText": { + "type": "boolean" + }, + "leading": { + "$ref": "#/$defs/widgetNode" + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "minLines": { + "type": [ + "number", + "null" + ] + }, + "autofocus": { + "type": "boolean" + }, + "showClear": { + "type": "boolean" + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "allowTapOutside": { + "type": "boolean" + }, + "valid": { + "type": "boolean" + }, + "loading": { + "type": "boolean" + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "autofillHints": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "disabled": { + "type": "boolean" + }, + "textInputAction": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "keyboardType": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "trailingHint": { + "$ref": "#/$defs/widgetNode" + } + }, + "required": [ + "hint" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdList", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "paginator": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "assumedItemHeight": { + "type": [ + "number", + "null" + ] + }, + "footer": { + "$ref": "#/$defs/widgetNode" + }, + "header": { + "$ref": "#/$defs/widgetNode" + }, + "padding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "physics": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "primary": { + "type": [ + "boolean", + "null" + ] + }, + "retryConfig": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "scrollController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "shrinkWrap": { + "type": [ + "boolean", + "null" + ] + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdListEmpty", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": [ + "string", + "null" + ] + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdListItem", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "active": { + "type": [ + "boolean", + "null" + ] + }, + "borderRadius": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "topLeft": { + "type": [ + "number", + "null" + ] + }, + "topRight": { + "type": [ + "number", + "null" + ] + }, + "bottomLeft": { + "type": [ + "number", + "null" + ] + }, + "bottomRight": { + "type": [ + "number", + "null" + ] + } + } + }, + "disabled": { + "type": [ + "boolean", + "null" + ] + }, + "isSelected": { + "type": [ + "boolean", + "null" + ] + }, + "leading": { + "$ref": "#/$defs/widgetNode" + }, + "padding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "selectDisabled": { + "type": "boolean" + }, + "subContent": { + "$ref": "#/$defs/widgetNode" + }, + "subtitle": { + "$ref": "#/$defs/widgetNode" + }, + "title": { + "$ref": "#/$defs/widgetNode" + }, + "tradeLeadingForSelectionControl": { + "type": "boolean" + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "trailing": { + "$ref": "#/$defs/widgetNode" + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "width": { + "type": [ + "number", + "null" + ] + }, + "selectionControl": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdListLoading", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": {} + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdLoading", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": {} + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdNotification", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "message": { + "type": "string" + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "subMessage": { + "type": [ + "string", + "null" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "canDismiss": { + "type": "boolean" + }, + "removing": { + "type": "boolean" + }, + "haptics": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "didConfirm": { + "type": "boolean" + }, + "duration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "message", + "type" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdRadio", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "label": { + "type": [ + "string", + "null" + ] + }, + "checked": { + "type": "boolean" + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "disabled": { + "type": "boolean" + } + }, + "required": [ + "checked" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdScaffold", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "body": { + "$ref": "#/$defs/widgetNode" + }, + "appBars": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "debugName": { + "type": [ + "string", + "null" + ] + }, + "toggleDrawerShortcut": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "extendBodyBehindAppBar": { + "type": "boolean" + }, + "backgroundColor": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + }, + "drawer": { + "$ref": "#/$defs/widgetNode" + }, + "drawerWidth": { + "type": "number" + }, + "reflowBreakpoint": { + "type": [ + "number", + "null" + ] + }, + "resizeToAvoidBottomInset": { + "type": [ + "boolean", + "null" + ] + }, + "searchController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "primaryScrollController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "body" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdScaffoldBody", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "minimumPadding": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "left": { + "type": [ + "number", + "null" + ] + }, + "top": { + "type": [ + "number", + "null" + ] + }, + "right": { + "type": [ + "number", + "null" + ] + }, + "bottom": { + "type": [ + "number", + "null" + ] + } + } + }, + "slivers": { + "type": "array", + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Array of child widgets" + }, + "scrollController": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "backgroundColor": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + }, + "autoSpaceChildren": { + "type": "boolean" + }, + "addContainer": { + "type": "boolean" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdSelect", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "items": { + "type": "array", + "items": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "placeholder": { + "type": [ + "string", + "null" + ] + }, + "disabled": { + "type": "boolean" + }, + "focusNode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "value": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "valid": { + "type": "boolean" + }, + "onSurface": { + "type": "boolean" + } + }, + "required": [ + "items" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdSheet", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": {} + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdSlider", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "hint": { + "type": [ + "string", + "null" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "disabled": { + "type": "boolean" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdSwitch", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "children": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "value": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "disabled": { + "type": "boolean" + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "expand": { + "type": "boolean" + } + }, + "required": [ + "children", + "value" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdTable", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "columns": { + "type": "array", + "items": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "rows": { + "type": "array", + "items": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "selectedRows": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "header": { + "$ref": "#/$defs/widgetNode" + }, + "allowSort": { + "type": "boolean" + }, + "rowCount": { + "type": "number" + }, + "density": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + } + }, + "required": [ + "columns", + "rows", + "rowCount" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdTag", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "child": { + "$ref": "#/$defs/widgetNode" + }, + "color": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + } + }, + "required": [ + "child" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.caption", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.h", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.hl", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.hs", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.hxs", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.l", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.ll", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.ls", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.lxs", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.p", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.pl", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.ps", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdText.pxs", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "text": { + "type": "string" + }, + "textAlign": { + "type": [ + "string", + "null" + ], + "enum": [ + "left", + "right", + "center", + "justify", + "start", + "end" + ] + }, + "maxLines": { + "type": [ + "number", + "null" + ] + }, + "overflow": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "decoration": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "size": { + "type": "string", + "enum": [ + "xs", + "s", + "m", + "l" + ] + }, + "type": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "fontWeight": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "lineHeight": { + "type": [ + "number", + "null" + ] + }, + "processLinks": { + "type": "boolean" + }, + "color": { + "type": [ + "string", + "null" + ], + "description": "Color as hex string (e.g., \"#FF0000\") or color name" + } + }, + "required": [ + "text" + ] + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "type": { + "type": "string", + "const": "LdTimePicker", + "description": "The widget type name." + }, + "properties": { + "type": "object", + "additionalProperties": false, + "properties": { + "useRootNavigator": { + "type": "boolean" + }, + "disabled": { + "type": "boolean" + }, + "label": { + "type": [ + "string", + "null" + ] + }, + "buttonMode": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "value": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object" + }, + { + "type": "array" + } + ] + }, + "minutePrecision": { + "type": "number" + } + } + }, + "children": { + "type": [ + "array", + "null" + ], + "items": { + "$ref": "#/$defs/widgetNode" + }, + "description": "Optional array of child widgets. Each child must follow the same widget node structure." + } + }, + "required": [ + "type" + ] + } + ], + "description": "A widget node. Must match one of the widget type schemas." + } + } +} \ No newline at end of file diff --git a/pubspec.yaml b/pubspec.yaml index 293e85cb..acdbeb4d 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -10,6 +10,7 @@ workspace: - packages/liquid_flutter_test_utils - packages/liquid_flutter/extension/devtools/liquid_flutter_extension - apps/example + - apps/liquid-gen dev_dependencies: melos: ^7.1.0