firka/flutter
firka/flutter
5
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Switch to SemanticAction (#4791)

Browse Source 
This patch updates the framework to use the new SemanticAction in
semantics.mojom.
This commit is contained in:
Adam Barth 2016-06-30 17:38:05 -07:00 committed by GitHub
parent 639532bd51
commit 95a26ab0e8
13 changed files with 213 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bin/cache/engine.version vendored
View File

@ -1 +1 @@
bb9865538b3daf2b452fdff9e767cee5139695e1
71ce354a447dc3384c4e8b0f031eaa9f313d29e9

2
packages/flutter/lib/src/gestures/drag.dart
View File

@ -90,7 +90,7 @@ class DragEndDetails {
/// Creates details for a [GestureDragEndCallback].
///
/// The [velocity] argument must not be null.
DragEndDetails({ this.velocity }) {
DragEndDetails({ this.velocity: Velocity.zero }) {
assert(velocity != null);
}

28
packages/flutter/lib/src/material/toggleable.dart
View File

@ -268,29 +268,19 @@ abstract class RenderToggleable extends RenderConstrainedBox implements Semantic
@override
Iterable<SemanticAnnotator> getSemanticAnnotators() sync* {
yield (SemanticsNode semantics) {
semantics.hasCheckedState = true;
semantics.isChecked = _value;
semantics.canBeTapped = isInteractive;
semantics
..hasCheckedState = true
..isChecked = _value;
if (isInteractive)
semantics.addAction(SemanticAction.tap);
};
}
@override
void handleSemanticTap() => _handleTap();
@override
void handleSemanticLongPress() { }
@override
void handleSemanticScrollLeft() { }
@override
void handleSemanticScrollRight() { }
@override
void handleSemanticScrollUp() { }
@override
void handleSemanticScrollDown() { }
void performAction(SemanticAction action) {
if (action == SemanticAction.tap)
_handleTap();
}
@override
void debugFillDescription(List<String> description) {

106
packages/flutter/lib/src/rendering/proxy_box.dart
View File

@ -2119,63 +2119,65 @@ class RenderSemanticsGestureHandler extends RenderProxyBox implements SemanticAc
Iterable<SemanticAnnotator> getSemanticAnnotators() sync* {
if (hasSemantics) {
yield (SemanticsNode semantics) {
semantics.canBeTapped = onTap != null;
semantics.canBeLongPressed = onLongPress != null;
semantics.canBeScrolledHorizontally = onHorizontalDragUpdate != null;
semantics.canBeScrolledVertically = onVerticalDragUpdate != null;
if (onTap != null)
semantics.addAction(SemanticAction.tap);
if (onLongPress != null)
semantics.addAction(SemanticAction.longPress);
if (onHorizontalDragUpdate != null)
semantics.addHorizontalScrollingActions();
if (onVerticalDragUpdate != null)
semantics.addVerticalScrollingActions();
};
}
}
@override
void handleSemanticTap() {
if (onTap != null)
onTap();
}
@override
void handleSemanticLongPress() {
if (onLongPress != null)
onLongPress();
}
@override
void handleSemanticScrollLeft() {
if (onHorizontalDragUpdate != null) {
final double primaryDelta = size.width * -scrollFactor;
onHorizontalDragUpdate(new DragUpdateDetails(
delta: new Offset(primaryDelta, 0.0), primaryDelta: primaryDelta
));
}
}
@override
void handleSemanticScrollRight() {
if (onHorizontalDragUpdate != null) {
final double primaryDelta = size.width * scrollFactor;
onHorizontalDragUpdate(new DragUpdateDetails(
delta: new Offset(primaryDelta, 0.0), primaryDelta: primaryDelta
));
}
}
@override
void handleSemanticScrollUp() {
if (onVerticalDragUpdate != null) {
final double primaryDelta = size.height * -scrollFactor;
onVerticalDragUpdate(new DragUpdateDetails(
delta: new Offset(0.0, primaryDelta), primaryDelta: primaryDelta
));
}
}
@override
void handleSemanticScrollDown() {
if (onVerticalDragUpdate != null) {
final double primaryDelta = size.height * scrollFactor;
onVerticalDragUpdate(new DragUpdateDetails(
delta: new Offset(0.0, primaryDelta), primaryDelta: primaryDelta
));
void performAction(SemanticAction action) {
switch (action) {
case SemanticAction.tap:
if (onTap != null)
onTap();
break;
case SemanticAction.longPress:
if (onLongPress != null)
onLongPress();
break;
case SemanticAction.scrollLeft:
if (onHorizontalDragUpdate != null) {
final double primaryDelta = size.width * -scrollFactor;
onHorizontalDragUpdate(new DragUpdateDetails(
delta: new Offset(primaryDelta, 0.0), primaryDelta: primaryDelta
));
}
break;
case SemanticAction.scrollRight:
if (onHorizontalDragUpdate != null) {
final double primaryDelta = size.width * scrollFactor;
onHorizontalDragUpdate(new DragUpdateDetails(
delta: new Offset(primaryDelta, 0.0), primaryDelta: primaryDelta
));
}
break;
case SemanticAction.scrollUp:
if (onVerticalDragUpdate != null) {
final double primaryDelta = size.height * -scrollFactor;
onVerticalDragUpdate(new DragUpdateDetails(
delta: new Offset(0.0, primaryDelta), primaryDelta: primaryDelta
));
}
break;
case SemanticAction.scrollDown:
if (onVerticalDragUpdate != null) {
final double primaryDelta = size.height * scrollFactor;
onVerticalDragUpdate(new DragUpdateDetails(
delta: new Offset(0.0, primaryDelta), primaryDelta: primaryDelta
));
}
break;
case SemanticAction.increase:
case SemanticAction.decrease:
assert(false);
break;
}
}
}

185
packages/flutter/lib/src/rendering/semantics.dart
View File

@ -7,11 +7,34 @@ import 'dart:ui' show Rect;
import 'package:flutter/foundation.dart';
import 'package:flutter/painting.dart';
import 'package:meta/meta.dart';
import 'package:sky_services/semantics/semantics.mojom.dart' as mojom;
import 'package:vector_math/vector_math_64.dart';
import 'node.dart';
enum SemanticAction {
tap,
longPress,
scrollLeft,
scrollRight,
scrollUp,
scrollDown,
increase,
decrease,
}
/// Interface for [RenderObject]s to implement when they want to support
/// being tapped, etc.
///
/// These handlers will only be called if the relevant flag is set
/// (e.g. [handleSemanticTap]() will only be called if
/// [SemanticsNode.canBeTapped] is true, [handleSemanticScrollDown]() will only
/// be called if [SemanticsNode.canBeScrolledVertically] is true, etc).
abstract class SemanticActionHandler { // ignore: one_member_abstracts
void performAction(SemanticAction action);
}
/// The type of function returned by [RenderObject.getSemanticAnnotators()].
///
/// These callbacks are called with the [SemanticsNode] object that
@ -22,40 +45,9 @@ import 'node.dart';
/// contract that semantic annotators must follow.
typedef void SemanticAnnotator(SemanticsNode semantics);
/// Interface for [RenderObject]s to implement when they want to support
/// being tapped, etc.
///
/// These handlers will only be called if the relevant flag is set
/// (e.g. [handleSemanticTap]() will only be called if
/// [SemanticsNode.canBeTapped] is true, [handleSemanticScrollDown]() will only
/// be called if [SemanticsNode.canBeScrolledVertically] is true, etc).
abstract class SemanticActionHandler {
/// Called when the user taps on the render object.
void handleSemanticTap() { }
/// Called when the user presses on the render object for a long period of time.
void handleSemanticLongPress() { }
/// Called when the user scrolls to the left.
void handleSemanticScrollLeft() { }
/// Called when the user scrolls to the right.
void handleSemanticScrollRight() { }
/// Called when the user scrolls up.
void handleSemanticScrollUp() { }
/// Called when the user scrolls down.
void handleSemanticScrollDown() { }
}
enum _SemanticFlags {
mergeAllDescendantsIntoThisNode,
inheritedMergeAllDescendantsIntoThisNode, // whether an ancestor had mergeAllDescendantsIntoThisNode set
canBeTapped,
canBeLongPressed,
canBeScrolledHorizontally,
canBeScrolledVertically,
hasCheckedState,
isChecked,
}
@ -137,6 +129,27 @@ class SemanticsNode extends AbstractNode {
// FLAGS AND LABELS
// These are supposed to be set by SemanticAnnotator obtained from getSemanticAnnotators
final Set<SemanticAction> _actions = new Set<SemanticAction>();
void addAction(SemanticAction action) {
if (_actions.add(action))
_markDirty();
}
void addHorizontalScrollingActions() {
addAction(SemanticAction.scrollLeft);
addAction(SemanticAction.scrollRight);
}
void addVerticalScrollingActions() {
addAction(SemanticAction.scrollUp);
addAction(SemanticAction.scrollDown);
}
bool _hasAction(SemanticAction action) {
return _actionHandler != null && _actions.contains(action);
}
BitField<_SemanticFlags> _flags = new BitField<_SemanticFlags>.filled(_SemanticFlags.values.length, false);
void _setFlag(_SemanticFlags flag, bool value, { bool needsHandler: false }) {
@ -148,10 +161,6 @@ class SemanticsNode extends AbstractNode {
}
}
bool _canHandle(_SemanticFlags flag) {
return _actionHandler != null && _flags[flag];
}
/// Whether all this node and all of its descendants should be treated as one logical entity.
bool get mergeAllDescendantsIntoThisNode => _flags[_SemanticFlags.mergeAllDescendantsIntoThisNode];
set mergeAllDescendantsIntoThisNode(bool value) => _setFlag(_SemanticFlags.mergeAllDescendantsIntoThisNode, value);
@ -161,22 +170,6 @@ class SemanticsNode extends AbstractNode {
bool get _shouldMergeAllDescendantsIntoThisNode => mergeAllDescendantsIntoThisNode || _inheritedMergeAllDescendantsIntoThisNode;
/// Whether this node responds to tap gestures.
bool get canBeTapped => _flags[_SemanticFlags.canBeTapped];
set canBeTapped(bool value) => _setFlag(_SemanticFlags.canBeTapped, value, needsHandler: true);
/// Whether this node responds to long-press gestures.
bool get canBeLongPressed => _flags[_SemanticFlags.canBeLongPressed];
set canBeLongPressed(bool value) => _setFlag(_SemanticFlags.canBeLongPressed, value, needsHandler: true);
/// Whether this node responds to horizontal scrolling.
bool get canBeScrolledHorizontally => _flags[_SemanticFlags.canBeScrolledHorizontally];
set canBeScrolledHorizontally(bool value) => _setFlag(_SemanticFlags.canBeScrolledHorizontally, value, needsHandler: true);
/// Whether this node responds to vertical scrolling.
bool get canBeScrolledVertically => _flags[_SemanticFlags.canBeScrolledVertically];
set canBeScrolledVertically(bool value) => _setFlag(_SemanticFlags.canBeScrolledVertically, value, needsHandler: true);
/// Whether this node has Boolean state that can be controlled by the user.
bool get hasCheckedState => _flags[_SemanticFlags.hasCheckedState];
set hasCheckedState(bool value) => _setFlag(_SemanticFlags.hasCheckedState, value);
@ -199,6 +192,7 @@ class SemanticsNode extends AbstractNode {
/// Restore this node to its default state.
void reset() {
bool hadInheritedMergeAllDescendantsIntoThisNode = _inheritedMergeAllDescendantsIntoThisNode;
_actions.clear();
_flags.reset();
if (hadInheritedMergeAllDescendantsIntoThisNode)
_inheritedMergeAllDescendantsIntoThisNode = true;
@ -370,21 +364,16 @@ class SemanticsNode extends AbstractNode {
result.geometry.width = math.max(rect.width, 0.0);
result.geometry.height = math.max(rect.height, 0.0);
result.flags = new mojom.SemanticFlags();
result.flags.canBeTapped = canBeTapped;
result.flags.canBeLongPressed = canBeLongPressed;
result.flags.canBeScrolledHorizontally = canBeScrolledHorizontally;
result.flags.canBeScrolledVertically = canBeScrolledVertically;
result.flags.hasCheckedState = hasCheckedState;
result.flags.isChecked = isChecked;
result.strings = new mojom.SemanticStrings();
result.strings.label = label;
List<mojom.SemanticsNode> children = <mojom.SemanticsNode>[];
Set<SemanticAction> mergedActions = new Set<SemanticAction>();
mergedActions.addAll(_actions);
if (_shouldMergeAllDescendantsIntoThisNode) {
_visitDescendants((SemanticsNode node) {
result.flags.canBeTapped = result.flags.canBeTapped || node.canBeTapped;
result.flags.canBeLongPressed = result.flags.canBeLongPressed || node.canBeLongPressed;
result.flags.canBeScrolledHorizontally = result.flags.canBeScrolledHorizontally || node.canBeScrolledHorizontally;
result.flags.canBeScrolledVertically = result.flags.canBeScrolledVertically || node.canBeScrolledVertically;
mergedActions.addAll(node._actions);
result.flags.hasCheckedState = result.flags.hasCheckedState || node.hasCheckedState;
result.flags.isChecked = result.flags.isChecked || node.isChecked;
if (node.label != '')
@ -400,6 +389,9 @@ class SemanticsNode extends AbstractNode {
}
}
result.children = children;
result.actions = <int>[];
for (SemanticAction action in mergedActions)
result.actions.add(action.index);
_dirty = false;
}
return result;
@ -499,37 +491,47 @@ class SemanticsNode extends AbstractNode {
_dirtyNodes.clear();
}
static SemanticActionHandler _getSemanticActionHandlerForId(int id, { _SemanticFlags neededFlag }) {
assert(neededFlag != null);
static SemanticActionHandler _getSemanticActionHandlerForId(int id, { @required SemanticAction action }) {
assert(action != null);
SemanticsNode result = _nodes[id];
if (result != null && result._shouldMergeAllDescendantsIntoThisNode && !result._canHandle(neededFlag)) {
if (result != null && result._shouldMergeAllDescendantsIntoThisNode && !result._hasAction(action)) {
result._visitDescendants((SemanticsNode node) {
if (node._actionHandler != null && node._flags[neededFlag]) {
if (node._actionHandler != null && node._hasAction(action)) {
result = node;
return false; // found node, abort walk
}
return true; // continue walk
});
}
if (result == null || !result._canHandle(neededFlag))
if (result == null || !result._hasAction(action))
return null;
return result._actionHandler;
}
@override
String toString() {
return '$runtimeType($_id'
'${_dirty ? " (${ _dirtyNodes.contains(this) ? 'dirty' : 'STALE' })" : ""}'
'${_shouldMergeAllDescendantsIntoThisNode ? " (leaf merge)" : ""}'
'; $rect'
'${wasAffectedByClip ? " (clipped)" : ""}'
'${canBeTapped ? "; canBeTapped" : ""}'
'${canBeLongPressed ? "; canBeLongPressed" : ""}'
'${canBeScrolledHorizontally ? "; canBeScrolledHorizontally" : ""}'
'${canBeScrolledVertically ? "; canBeScrolledVertically" : ""}'
'${hasCheckedState ? (isChecked ? "; checked" : "; unchecked") : ""}'
'${label != "" ? "; \"$label\"" : ""}'
')';
StringBuffer buffer = new StringBuffer();
buffer.write('$runtimeType($_id');
if (_dirty)
buffer.write(" (${ _dirtyNodes.contains(this) ? 'dirty' : 'STALE' })");
if (_shouldMergeAllDescendantsIntoThisNode)
buffer.write(' (leaf merge)');
buffer.write('; $rect');
if (wasAffectedByClip)
buffer.write(' (clipped)');
for (SemanticAction action in _actions) {
buffer.write('; $action');
}
if (hasCheckedState) {
if (isChecked)
buffer.write('; checked');
else
buffer.write('; unchecked');
}
if (label.isNotEmpty)
buffer.write('; "$label"');
buffer.write(')');
return buffer.toString();
}
/// Returns a string representation of this node and its descendants.
@ -556,32 +558,9 @@ class SemanticsServer extends mojom.SemanticsServer {
}
@override
void tap(int nodeID) {
SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeTapped)?.handleSemanticTap();
}
@override
void longPress(int nodeID) {
SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeLongPressed)?.handleSemanticLongPress();
}
@override
void scrollLeft(int nodeID) {
SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeScrolledHorizontally)?.handleSemanticScrollLeft();
}
@override
void scrollRight(int nodeID) {
SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeScrolledHorizontally)?.handleSemanticScrollRight();
}
@override
void scrollUp(int nodeID) {
SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeScrolledVertically)?.handleSemanticScrollUp();
}
@override
void scrollDown(int nodeID) {
SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeScrolledVertically)?.handleSemanticScrollDown();
void performAction(int id, mojom.SemanticAction encodedAction) {
SemanticAction action = SemanticAction.values[encodedAction.mojoEnumValue];
SemanticActionHandler node = SemanticsNode._getSemanticActionHandlerForId(id, action: action);
node?.performAction(action);
}
}

63
packages/flutter/lib/src/widgets/semantics_debugger.dart
View File

@ -58,14 +58,14 @@ class _SemanticsDebuggerState extends State<SemanticsDebugger> {
void _handleTap() {
assert(_lastPointerDownLocation != null);
_SemanticsDebuggerListener.instance.handleTap(_lastPointerDownLocation);
_SemanticsDebuggerListener.instance._performAction(_lastPointerDownLocation, SemanticAction.tap);
setState(() {
_lastPointerDownLocation = null;
});
}
void _handleLongPress() {
assert(_lastPointerDownLocation != null);
_SemanticsDebuggerListener.instance.handleLongPress(_lastPointerDownLocation);
_SemanticsDebuggerListener.instance._performAction(_lastPointerDownLocation, SemanticAction.longPress);
setState(() {
_lastPointerDownLocation = null;
});
@ -107,10 +107,7 @@ class _SemanticsDebuggerEntry {
_SemanticsDebuggerEntry(this.id);
final int id;
bool canBeTapped = false;
bool canBeLongPressed = false;
bool canBeScrolledHorizontally = false;
bool canBeScrolledVertically = false;
final Set<SemanticAction> actions = new Set<SemanticAction>();
bool hasCheckedState = false;
bool isChecked = false;
String label;
@ -120,13 +117,14 @@ class _SemanticsDebuggerEntry {
@override
String toString() {
return '_SemanticsDebuggerEntry($id; $rect; "$label"'
'${canBeTapped ? "; canBeTapped" : ""}'
'${canBeLongPressed ? "; canBeLongPressed" : ""}'
'${canBeScrolledHorizontally ? "; canBeScrolledHorizontally" : ""}'
'${canBeScrolledVertically ? "; canBeScrolledVertically" : ""}'
'${hasCheckedState ? isChecked ? "; checked" : "; unchecked" : ""}'
')';
StringBuffer buffer = new StringBuffer();
buffer.write('_SemanticsDebuggerEntry($id; $rect; "$label"');
for (SemanticAction action in actions)
buffer.write('; $action');
buffer
..write('${hasCheckedState ? isChecked ? "; checked" : "; unchecked" : ""}')
..write(')');
return buffer.toString();
}
String toStringDeep([ String prefix = '']) {
@ -142,13 +140,14 @@ class _SemanticsDebuggerEntry {
void updateWith(mojom.SemanticsNode node) {
if (node.flags != null) {
canBeTapped = node.flags.canBeTapped;
canBeLongPressed = node.flags.canBeLongPressed;
canBeScrolledHorizontally = node.flags.canBeScrolledHorizontally;
canBeScrolledVertically = node.flags.canBeScrolledVertically;
hasCheckedState = node.flags.hasCheckedState;
isChecked = node.flags.isChecked;
}
if (node.actions != null) {
actions.clear();
for (int encodedAction in node.actions)
actions.add(SemanticAction.values[encodedAction]);
}
if (node.strings != null) {
assert(node.strings.label != null);
label = node.strings.label;
@ -190,6 +189,13 @@ class _SemanticsDebuggerEntry {
height: 0.8
);
bool get _isScrollable {
return actions.contains(SemanticAction.scrollLeft)
|| actions.contains(SemanticAction.scrollRight)
|| actions.contains(SemanticAction.scrollUp)
|| actions.contains(SemanticAction.scrollDown);
}
TextPainter textPainter;
void _updateMessage() {
List<String> annotations = <String>[];
@ -198,16 +204,16 @@ class _SemanticsDebuggerEntry {
annotations.add(isChecked ? 'checked' : 'unchecked');
wantsTap = true;
}
if (canBeTapped) {
if (actions.contains(SemanticAction.tap)) {
if (!wantsTap)
annotations.add('button');
} else {
if (wantsTap)
annotations.add('disabled');
}
if (canBeLongPressed)
if (actions.contains(SemanticAction.longPress))
annotations.add('long-pressable');
if (canBeScrolledHorizontally || canBeScrolledVertically)
if (_isScrollable)
annotations.add('scrollable');
String message;
if (annotations.isEmpty) {
@ -349,12 +355,11 @@ class _SemanticsDebuggerListener extends ChangeNotifier implements mojom.Semanti
return rootNode?.hitTest(position, filter);
}
void handleTap(Point position) {
_server.tap(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeTapped)?.id ?? 0);
}
void handleLongPress(Point position) {
_server.longPress(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeLongPressed)?.id ?? 0);
void _performAction(Point position, SemanticAction action) {
_SemanticsDebuggerEntry entry = _hitTest(position, (_SemanticsDebuggerEntry entry) => entry.actions.contains(action));
_server.performAction(entry?.id ?? 0, mojom.SemanticAction.values[action.index]);
}
void handlePanEnd(Point position, Velocity velocity) {
double vx = velocity.pixelsPerSecond.dx;
double vy = velocity.pixelsPerSecond.dy;
@ -362,14 +367,14 @@ class _SemanticsDebuggerListener extends ChangeNotifier implements mojom.Semanti
return;
if (vx.abs() > vy.abs()) {
if (vx.sign < 0)
_server.scrollLeft(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeScrolledHorizontally)?.id ?? 0);
_performAction(position, SemanticAction.scrollLeft);
else
_server.scrollRight(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeScrolledHorizontally)?.id ?? 0);
_performAction(position, SemanticAction.scrollRight);
} else {
if (vy.sign < 0)
_server.scrollUp(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeScrolledVertically)?.id ?? 0);
_performAction(position, SemanticAction.scrollUp);
else
_server.scrollDown(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeScrolledVertically)?.id ?? 0);
_performAction(position, SemanticAction.scrollDown);
}
}
}

10
packages/flutter/test/material/tooltip_test.dart
View File

@ -421,10 +421,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals('TIP'));
@ -443,10 +440,7 @@ void main() {
await tester.pump(const Duration(seconds: 2)); // faded in, show timer started (and at 0.0)
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals('TIP'));

11
packages/flutter/test/widget/buttons_test.dart
View File

@ -5,6 +5,7 @@
import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:sky_services/semantics/semantics.mojom.dart' as mojom;
import 'test_semantics.dart';
@ -23,10 +24,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals(''));
@ -37,10 +35,7 @@ void main() {
expect(client.updates[0].geometry.height, equals(600.0));
expect(client.updates[0].children.length, equals(1));
expect(client.updates[0].children[0].id, equals(1));
expect(client.updates[0].children[0].flags.canBeTapped, isTrue);
expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[0].actions, equals(<int>[mojom.SemanticAction.tap.mojoEnumValue]));
expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].children[0].flags.isChecked, isFalse);
expect(client.updates[0].children[0].strings.label, equals('Hello'));

45
packages/flutter/test/widget/semantics_1_test.dart
View File

@ -24,10 +24,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals('test1'));
@ -61,10 +58,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals('child1'));
@ -98,10 +92,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals(''));
@ -112,10 +103,7 @@ void main() {
expect(client.updates[0].geometry.height, equals(600.0));
expect(client.updates[0].children.length, equals(2));
expect(client.updates[0].children[0].id, equals(1));
expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[0].actions, isEmpty);
expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].children[0].flags.isChecked, isFalse);
expect(client.updates[0].children[0].strings.label, equals('child1'));
@ -126,10 +114,7 @@ void main() {
expect(client.updates[0].children[0].geometry.height, equals(10.0));
expect(client.updates[0].children[0].children.length, equals(0));
expect(client.updates[0].children[1].id, equals(2));
expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[1].actions, isEmpty);
expect(client.updates[0].children[1].flags.hasCheckedState, isFalse);
expect(client.updates[0].children[1].flags.isChecked, isFalse);
expect(client.updates[0].children[1].strings.label, equals('child2'));
@ -163,10 +148,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals('child1'));
@ -200,10 +182,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals(''));
@ -214,10 +193,7 @@ void main() {
expect(client.updates[0].geometry.height, equals(600.0));
expect(client.updates[0].children.length, equals(2));
expect(client.updates[0].children[0].id, equals(3));
expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[0].actions, isEmpty);
expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].children[0].flags.isChecked, isFalse);
expect(client.updates[0].children[0].strings.label, equals('child1'));
@ -228,10 +204,7 @@ void main() {
expect(client.updates[0].children[0].geometry.height, equals(10.0));
expect(client.updates[0].children[0].children.length, equals(0));
expect(client.updates[0].children[1].id, equals(2));
expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[1].actions, isEmpty);
expect(client.updates[0].children[1].flags.hasCheckedState, isFalse);
expect(client.updates[0].children[1].flags.isChecked, isFalse);
expect(client.updates[0].children[1].strings.label, equals('child2'));

35
packages/flutter/test/widget/semantics_2_test.dart
View File

@ -38,10 +38,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals(''));
@ -52,10 +49,7 @@ void main() {
expect(client.updates[0].geometry.height, equals(600.0));
expect(client.updates[0].children.length, equals(2));
expect(client.updates[0].children[0].id, equals(1));
expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[0].actions, isEmpty);
expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].children[0].flags.isChecked, isFalse);
expect(client.updates[0].children[0].strings.label, equals('child1'));
@ -66,10 +60,7 @@ void main() {
expect(client.updates[0].children[0].geometry.height, equals(10.0));
expect(client.updates[0].children[0].children.length, equals(0));
expect(client.updates[0].children[1].id, equals(2));
expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[1].actions, isEmpty);
expect(client.updates[0].children[1].flags.hasCheckedState, isFalse);
expect(client.updates[0].children[1].flags.isChecked, isFalse);
expect(client.updates[0].children[1].strings.label, equals('child2'));
@ -103,10 +94,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals('child1'));
@ -140,10 +128,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals(''));
@ -154,10 +139,7 @@ void main() {
expect(client.updates[0].geometry.height, equals(600.0));
expect(client.updates[0].children.length, equals(2));
expect(client.updates[0].children[0].id, equals(3));
expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[0].actions, isEmpty);
expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].children[0].flags.isChecked, isFalse);
expect(client.updates[0].children[0].strings.label, equals('child1'));
@ -168,10 +150,7 @@ void main() {
expect(client.updates[0].children[0].geometry.height, equals(10.0));
expect(client.updates[0].children[0].children.length, equals(0));
expect(client.updates[0].children[1].id, equals(2));
expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[1].actions, isEmpty);
expect(client.updates[0].children[1].flags.hasCheckedState, isFalse);
expect(client.updates[0].children[1].flags.isChecked, isFalse);
expect(client.updates[0].children[1].strings.label, equals('child2'));

20
packages/flutter/test/widget/semantics_3_test.dart
View File

@ -27,10 +27,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isTrue);
expect(client.updates[0].flags.isChecked, isTrue);
expect(client.updates[0].strings.label, equals('test'));
@ -55,10 +52,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isTrue);
expect(client.updates[0].flags.isChecked, isTrue);
expect(client.updates[0].strings.label, equals(''));
@ -83,10 +77,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals('test'));
@ -114,10 +105,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isTrue);
expect(client.updates[0].flags.isChecked, isTrue);
expect(client.updates[0].strings.label, equals('test'));

25
packages/flutter/test/widget/semantics_7_test.dart
View File

@ -46,10 +46,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isFalse);
expect(client.updates[0].flags.isChecked, isFalse);
expect(client.updates[0].strings.label, equals(''));
@ -60,10 +57,7 @@ void main() {
expect(client.updates[0].geometry.height, equals(600.0));
expect(client.updates[0].children.length, equals(2));
expect(client.updates[0].children[0].id, equals(1));
expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[0].actions, isEmpty);
expect(client.updates[0].children[0].flags.hasCheckedState, isTrue);
expect(client.updates[0].children[0].flags.isChecked, isTrue);
expect(client.updates[0].children[0].strings.label, equals(label));
@ -75,10 +69,7 @@ void main() {
expect(client.updates[0].children[0].children.length, equals(0));
// IDs 2 and 3 are used up by the nodes that get merged in
expect(client.updates[0].children[1].id, equals(4));
expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].children[1].actions, isEmpty);
expect(client.updates[0].children[1].flags.hasCheckedState, isTrue);
expect(client.updates[0].children[1].flags.isChecked, isTrue);
expect(client.updates[0].children[1].strings.label, equals(label));
@ -135,10 +126,7 @@ void main() {
}
expect(a.id, equals(1));
expect(a.flags.canBeTapped, isFalse);
expect(a.flags.canBeLongPressed, isFalse);
expect(a.flags.canBeScrolledHorizontally, isFalse);
expect(a.flags.canBeScrolledVertically, isFalse);
expect(a.actions, isEmpty);
expect(a.flags.hasCheckedState, isTrue);
expect(a.flags.isChecked, isTrue);
expect(a.strings.label, equals(label));
@ -150,10 +138,7 @@ void main() {
expect(a.children.length, equals(0));
expect(b.id, equals(4));
expect(b.flags.canBeTapped, isFalse);
expect(b.flags.canBeLongPressed, isFalse);
expect(b.flags.canBeScrolledHorizontally, isFalse);
expect(b.flags.canBeScrolledVertically, isFalse);
expect(b.actions, isEmpty);
expect(b.flags.hasCheckedState, isTrue);
expect(b.flags.isChecked, isTrue);
expect(b.strings.label, equals(label));

10
packages/flutter/test/widget/semantics_8_test.dart
View File

@ -34,10 +34,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isTrue);
expect(client.updates[0].flags.isChecked, isTrue);
expect(client.updates[0].strings.label, equals('label'));
@ -73,10 +70,7 @@ void main() {
);
expect(client.updates.length, equals(2));
expect(client.updates[0].id, equals(0));
expect(client.updates[0].flags.canBeTapped, isFalse);
expect(client.updates[0].flags.canBeLongPressed, isFalse);
expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
expect(client.updates[0].actions, isEmpty);
expect(client.updates[0].flags.hasCheckedState, isTrue);
expect(client.updates[0].flags.isChecked, isTrue);
expect(client.updates[0].strings.label, equals('label'));