mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
Adds an `includeSemantics` property to the Shortcuts widget. @gspencergoog and I discussed this change to make introducing Shortcuts easier on the MenuAnchor widget. This change should also make testing semantics trees slightly less onerous (assuming this doesn't harm accessibility, that is). On the point of accessibility, I'm not sure what useful semantic information is exposed by the Shortcuts widget's semantic node, since it's basically just an unfocusable keyboard listener. However, I kept the `includeSemantics` defaulting to true so as to not break semantics tests in the Flutter repo. Fixes https://github.com/flutter/flutter/issues/152076
2207 lines
80 KiB
Dart
2207 lines
80 KiB
Dart
// Copyright 2014 The Flutter Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:leak_tracker_flutter_testing/leak_tracker_flutter_testing.dart';
|
|
|
|
import 'semantics_tester.dart';
|
|
|
|
void main() {
|
|
group(LogicalKeySet, () {
|
|
test('LogicalKeySet passes parameters correctly.', () {
|
|
final LogicalKeySet set1 = LogicalKeySet(LogicalKeyboardKey.keyA);
|
|
final LogicalKeySet set2 = LogicalKeySet(
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
);
|
|
final LogicalKeySet set3 = LogicalKeySet(
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyC,
|
|
);
|
|
final LogicalKeySet set4 = LogicalKeySet(
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyC,
|
|
LogicalKeyboardKey.keyD,
|
|
);
|
|
final LogicalKeySet setFromSet = LogicalKeySet.fromSet(<LogicalKeyboardKey>{
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyC,
|
|
LogicalKeyboardKey.keyD,
|
|
});
|
|
expect(
|
|
set1.keys,
|
|
equals(<LogicalKeyboardKey>{
|
|
LogicalKeyboardKey.keyA,
|
|
}),
|
|
);
|
|
expect(
|
|
set2.keys,
|
|
equals(<LogicalKeyboardKey>{
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
}),
|
|
);
|
|
expect(
|
|
set3.keys,
|
|
equals(<LogicalKeyboardKey>{
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyC,
|
|
}),
|
|
);
|
|
expect(
|
|
set4.keys,
|
|
equals(<LogicalKeyboardKey>{
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyC,
|
|
LogicalKeyboardKey.keyD,
|
|
}),
|
|
);
|
|
expect(
|
|
setFromSet.keys,
|
|
equals(<LogicalKeyboardKey>{
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyC,
|
|
LogicalKeyboardKey.keyD,
|
|
}),
|
|
);
|
|
});
|
|
|
|
test('LogicalKeySet works as a map key.', () {
|
|
final LogicalKeySet set1 = LogicalKeySet(LogicalKeyboardKey.keyA);
|
|
final LogicalKeySet set2 = LogicalKeySet(
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyC,
|
|
LogicalKeyboardKey.keyD,
|
|
);
|
|
final LogicalKeySet set3 = LogicalKeySet(
|
|
LogicalKeyboardKey.keyD,
|
|
LogicalKeyboardKey.keyC,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyA,
|
|
);
|
|
final LogicalKeySet set4 = LogicalKeySet.fromSet(<LogicalKeyboardKey>{
|
|
LogicalKeyboardKey.keyD,
|
|
LogicalKeyboardKey.keyC,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyA,
|
|
});
|
|
final Map<LogicalKeySet, String> map = <LogicalKeySet, String>{set1: 'one'};
|
|
expect(set2 == set3, isTrue);
|
|
expect(set2 == set4, isTrue);
|
|
expect(set2.hashCode, set3.hashCode);
|
|
expect(set2.hashCode, set4.hashCode);
|
|
expect(map.containsKey(set1), isTrue);
|
|
expect(map.containsKey(LogicalKeySet(LogicalKeyboardKey.keyA)), isTrue);
|
|
expect(
|
|
set2,
|
|
equals(LogicalKeySet.fromSet(<LogicalKeyboardKey>{
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
LogicalKeyboardKey.keyC,
|
|
LogicalKeyboardKey.keyD,
|
|
})),
|
|
);
|
|
});
|
|
|
|
testWidgets('handles two keys', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
LogicalKeySet(
|
|
LogicalKeyboardKey.keyC,
|
|
LogicalKeyboardKey.control,
|
|
),
|
|
(Intent intent) { invoked += 1; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// LCtrl -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// KeyC -> LCtrl: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// RCtrl -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlRight);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlRight);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// LCtrl -> LShift -> KeyC: Reject
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 0);
|
|
invoked = 0;
|
|
|
|
// LCtrl -> KeyA -> KeyC: Reject
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(invoked, 0);
|
|
invoked = 0;
|
|
|
|
expect(HardwareKeyboard.instance.logicalKeysPressed, isEmpty);
|
|
});
|
|
|
|
test('LogicalKeySet.hashCode is stable', () {
|
|
final LogicalKeySet set1 = LogicalKeySet(LogicalKeyboardKey.keyA);
|
|
expect(set1.hashCode, set1.hashCode);
|
|
|
|
final LogicalKeySet set2 = LogicalKeySet(LogicalKeyboardKey.keyA, LogicalKeyboardKey.keyB);
|
|
expect(set2.hashCode, set2.hashCode);
|
|
|
|
final LogicalKeySet set3 = LogicalKeySet(LogicalKeyboardKey.keyA, LogicalKeyboardKey.keyB, LogicalKeyboardKey.keyC);
|
|
expect(set3.hashCode, set3.hashCode);
|
|
|
|
final LogicalKeySet set4 = LogicalKeySet(LogicalKeyboardKey.keyA, LogicalKeyboardKey.keyB, LogicalKeyboardKey.keyC, LogicalKeyboardKey.keyD);
|
|
expect(set4.hashCode, set4.hashCode);
|
|
});
|
|
|
|
test('LogicalKeySet.hashCode is order-independent', () {
|
|
expect(
|
|
LogicalKeySet(LogicalKeyboardKey.keyA).hashCode,
|
|
LogicalKeySet(LogicalKeyboardKey.keyA).hashCode,
|
|
);
|
|
expect(
|
|
LogicalKeySet(LogicalKeyboardKey.keyA, LogicalKeyboardKey.keyB).hashCode,
|
|
LogicalKeySet(LogicalKeyboardKey.keyB, LogicalKeyboardKey.keyA).hashCode,
|
|
);
|
|
expect(
|
|
LogicalKeySet(LogicalKeyboardKey.keyA, LogicalKeyboardKey.keyB, LogicalKeyboardKey.keyC).hashCode,
|
|
LogicalKeySet(LogicalKeyboardKey.keyC, LogicalKeyboardKey.keyB, LogicalKeyboardKey.keyA).hashCode,
|
|
);
|
|
expect(
|
|
LogicalKeySet(LogicalKeyboardKey.keyA, LogicalKeyboardKey.keyB, LogicalKeyboardKey.keyC, LogicalKeyboardKey.keyD).hashCode,
|
|
LogicalKeySet(LogicalKeyboardKey.keyD, LogicalKeyboardKey.keyC, LogicalKeyboardKey.keyB, LogicalKeyboardKey.keyA).hashCode,
|
|
);
|
|
});
|
|
|
|
testWidgets('isActivatedBy works as expected', (WidgetTester tester) async {
|
|
// Collect some key events to use for testing.
|
|
final List<KeyEvent> events = <KeyEvent>[];
|
|
await tester.pumpWidget(
|
|
Focus(
|
|
autofocus: true,
|
|
onKeyEvent: (FocusNode node, KeyEvent event) {
|
|
events.add(event);
|
|
return KeyEventResult.ignored;
|
|
},
|
|
child: const SizedBox(),
|
|
),
|
|
);
|
|
|
|
final LogicalKeySet set = LogicalKeySet(LogicalKeyboardKey.keyA, LogicalKeyboardKey.control);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(set, events.last), isTrue);
|
|
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(set, events.last), isTrue);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(set, events.last), isFalse);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(ShortcutActivator.isActivatedBy(set, events.last), isFalse);
|
|
});
|
|
|
|
test('LogicalKeySet diagnostics work.', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
LogicalKeySet(
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
).debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(1));
|
|
expect(description[0], equals('keys: Key A + Key B'));
|
|
});
|
|
});
|
|
|
|
group(SingleActivator, () {
|
|
testWidgets('handles Ctrl-C', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
const SingleActivator(
|
|
LogicalKeyboardKey.keyC,
|
|
control: true,
|
|
),
|
|
(Intent intent) { invoked += 1; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// LCtrl -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// KeyC -> LCtrl: Reject
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
invoked = 0;
|
|
|
|
// LShift -> LCtrl -> KeyC: Reject
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
invoked = 0;
|
|
|
|
// With Ctrl-C pressed, KeyA -> Release KeyA: Reject
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
invoked = 0;
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
invoked = 0;
|
|
|
|
// LCtrl -> KeyA -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
invoked = 0;
|
|
|
|
// RCtrl -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlRight);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlRight);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// LCtrl -> RCtrl -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlRight);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlRight);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// While holding Ctrl-C, press KeyA: Reject
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
expect(HardwareKeyboard.instance.logicalKeysPressed, isEmpty);
|
|
}, variant: KeySimulatorTransitModeVariant.all());
|
|
|
|
testWidgets('handles repeated events', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
const SingleActivator(
|
|
LogicalKeyboardKey.keyC,
|
|
control: true,
|
|
),
|
|
(Intent intent) { invoked += 1; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// LCtrl -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 2);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 2);
|
|
invoked = 0;
|
|
|
|
expect(HardwareKeyboard.instance.logicalKeysPressed, isEmpty);
|
|
}, variant: KeySimulatorTransitModeVariant.all());
|
|
|
|
testWidgets('rejects repeated events if requested', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
const SingleActivator(
|
|
LogicalKeyboardKey.keyC,
|
|
control: true,
|
|
includeRepeats: false,
|
|
),
|
|
(Intent intent) { invoked += 1; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// LCtrl -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
expect(HardwareKeyboard.instance.logicalKeysPressed, isEmpty);
|
|
}, variant: KeySimulatorTransitModeVariant.all());
|
|
|
|
testWidgets('handles Shift-Ctrl-C', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
const SingleActivator(
|
|
LogicalKeyboardKey.keyC,
|
|
shift: true,
|
|
control: true,
|
|
),
|
|
(Intent intent) { invoked += 1; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// LShift -> LCtrl -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// LCtrl -> LShift -> KeyC: Accept
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// LCtrl -> KeyC -> LShift: Reject
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 0);
|
|
invoked = 0;
|
|
|
|
expect(HardwareKeyboard.instance.logicalKeysPressed, isEmpty);
|
|
});
|
|
|
|
testWidgets('isActivatedBy works as expected', (WidgetTester tester) async {
|
|
// Collect some key events to use for testing.
|
|
final List<KeyEvent> events = <KeyEvent>[];
|
|
await tester.pumpWidget(
|
|
Focus(
|
|
autofocus: true,
|
|
onKeyEvent: (FocusNode node, KeyEvent event) {
|
|
events.add(event);
|
|
return KeyEventResult.ignored;
|
|
},
|
|
child: const SizedBox(),
|
|
),
|
|
);
|
|
|
|
const SingleActivator singleActivator = SingleActivator(LogicalKeyboardKey.keyA, control: true);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isTrue);
|
|
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isTrue);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isFalse);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isFalse);
|
|
|
|
const SingleActivator noRepeatSingleActivator = SingleActivator(LogicalKeyboardKey.keyA, control: true, includeRepeats: false);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(noRepeatSingleActivator, events.last), isTrue);
|
|
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(noRepeatSingleActivator, events.last), isFalse);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(noRepeatSingleActivator, events.last), isFalse);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(ShortcutActivator.isActivatedBy(noRepeatSingleActivator, events.last), isFalse);
|
|
});
|
|
|
|
testWidgets('numLock works as expected when set to LockState.locked', (WidgetTester tester) async {
|
|
// Collect some key events to use for testing.
|
|
final List<KeyEvent> events = <KeyEvent>[];
|
|
await tester.pumpWidget(
|
|
Focus(
|
|
autofocus: true,
|
|
onKeyEvent: (FocusNode node, KeyEvent event) {
|
|
events.add(event);
|
|
return KeyEventResult.ignored;
|
|
},
|
|
child: const SizedBox(),
|
|
),
|
|
);
|
|
|
|
const SingleActivator singleActivator = SingleActivator(LogicalKeyboardKey.numpad4, numLock: LockState.locked);
|
|
|
|
// Lock NumLock.
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.numLock);
|
|
expect(HardwareKeyboard.instance.lockModesEnabled.contains(KeyboardLockMode.numLock), isTrue);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.numpad4);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isTrue);
|
|
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.numpad4);
|
|
|
|
// Unlock NumLock.
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.numLock);
|
|
expect(HardwareKeyboard.instance.lockModesEnabled.contains(KeyboardLockMode.numLock), isFalse);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.numpad4);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isFalse);
|
|
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.numpad4);
|
|
});
|
|
|
|
testWidgets('numLock works as expected when set to LockState.unlocked', (WidgetTester tester) async {
|
|
// Collect some key events to use for testing.
|
|
final List<KeyEvent> events = <KeyEvent>[];
|
|
await tester.pumpWidget(
|
|
Focus(
|
|
autofocus: true,
|
|
onKeyEvent: (FocusNode node, KeyEvent event) {
|
|
events.add(event);
|
|
return KeyEventResult.ignored;
|
|
},
|
|
child: const SizedBox(),
|
|
),
|
|
);
|
|
|
|
const SingleActivator singleActivator = SingleActivator(LogicalKeyboardKey.numpad4, numLock: LockState.unlocked);
|
|
|
|
// Lock NumLock.
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.numLock);
|
|
expect(HardwareKeyboard.instance.lockModesEnabled.contains(KeyboardLockMode.numLock), isTrue);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.numpad4);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isFalse);
|
|
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.numpad4);
|
|
|
|
// Unlock NumLock.
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.numLock);
|
|
expect(HardwareKeyboard.instance.lockModesEnabled.contains(KeyboardLockMode.numLock), isFalse);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.numpad4);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isTrue);
|
|
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.numpad4);
|
|
});
|
|
|
|
testWidgets('numLock works as expected when set to LockState.ignored', (WidgetTester tester) async {
|
|
// Collect some key events to use for testing.
|
|
final List<KeyEvent> events = <KeyEvent>[];
|
|
await tester.pumpWidget(
|
|
Focus(
|
|
autofocus: true,
|
|
onKeyEvent: (FocusNode node, KeyEvent event) {
|
|
events.add(event);
|
|
return KeyEventResult.ignored;
|
|
},
|
|
child: const SizedBox(),
|
|
),
|
|
);
|
|
|
|
const SingleActivator singleActivator = SingleActivator(LogicalKeyboardKey.numpad4);
|
|
|
|
// Lock NumLock.
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.numLock);
|
|
expect(HardwareKeyboard.instance.lockModesEnabled.contains(KeyboardLockMode.numLock), isTrue);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.numpad4);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isTrue);
|
|
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.numpad4);
|
|
|
|
// Unlock NumLock.
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.numLock);
|
|
expect(HardwareKeyboard.instance.lockModesEnabled.contains(KeyboardLockMode.numLock), isFalse);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.numpad4);
|
|
expect(ShortcutActivator.isActivatedBy(singleActivator, events.last), isTrue);
|
|
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.numpad4);
|
|
});
|
|
|
|
group('diagnostics.', () {
|
|
test('single key', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
const SingleActivator(
|
|
LogicalKeyboardKey.keyA,
|
|
).debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(1));
|
|
expect(description[0], equals('keys: Key A'));
|
|
});
|
|
|
|
test('no repeats', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
const SingleActivator(
|
|
LogicalKeyboardKey.keyA,
|
|
includeRepeats: false,
|
|
).debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(2));
|
|
expect(description[0], equals('keys: Key A'));
|
|
expect(description[1], equals('excluding repeats'));
|
|
});
|
|
|
|
test('combination', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
const SingleActivator(
|
|
LogicalKeyboardKey.keyA,
|
|
control: true,
|
|
shift: true,
|
|
alt: true,
|
|
meta: true,
|
|
).debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(1));
|
|
expect(description[0], equals('keys: Control + Alt + Meta + Shift + Key A'));
|
|
});
|
|
});
|
|
});
|
|
|
|
group(Shortcuts, () {
|
|
testWidgets('Default constructed Shortcuts has empty shortcuts', (WidgetTester tester) async {
|
|
const Shortcuts shortcuts = Shortcuts(shortcuts: <LogicalKeySet, Intent>{}, child: SizedBox());
|
|
await tester.pumpWidget(shortcuts);
|
|
expect(shortcuts.shortcuts, isNotNull);
|
|
expect(shortcuts.shortcuts, isEmpty);
|
|
});
|
|
|
|
testWidgets('Default constructed Shortcuts.manager has empty shortcuts', (WidgetTester tester) async {
|
|
final ShortcutManager manager = ShortcutManager();
|
|
addTearDown(manager.dispose);
|
|
expect(manager.shortcuts, isNotNull);
|
|
expect(manager.shortcuts, isEmpty);
|
|
final Shortcuts shortcuts = Shortcuts.manager(manager: manager, child: const SizedBox());
|
|
await tester.pumpWidget(shortcuts);
|
|
expect(shortcuts.shortcuts, isNotNull);
|
|
expect(shortcuts.shortcuts, isEmpty);
|
|
});
|
|
|
|
testWidgets('Shortcuts.manager passes on shortcuts', (WidgetTester tester) async {
|
|
final Map<LogicalKeySet, Intent> testShortcuts = <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.shift): const TestIntent(),
|
|
};
|
|
final ShortcutManager manager = ShortcutManager(shortcuts: testShortcuts);
|
|
addTearDown(manager.dispose);
|
|
expect(manager.shortcuts, isNotNull);
|
|
expect(manager.shortcuts, equals(testShortcuts));
|
|
final Shortcuts shortcuts = Shortcuts.manager(manager: manager, child: const SizedBox());
|
|
await tester.pumpWidget(shortcuts);
|
|
expect(shortcuts.shortcuts, isNotNull);
|
|
expect(shortcuts.shortcuts, equals(testShortcuts));
|
|
});
|
|
|
|
testWidgets('ShortcutManager handles shortcuts', (WidgetTester tester) async {
|
|
final GlobalKey containerKey = GlobalKey();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.shift): const TestIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
bool invoked = false;
|
|
await tester.pumpWidget(
|
|
Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invoked = true;
|
|
return true;
|
|
},
|
|
),
|
|
},
|
|
child: Shortcuts.manager(
|
|
manager: testManager,
|
|
child: Focus(
|
|
autofocus: true,
|
|
child: SizedBox(key: containerKey, width: 100, height: 100),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, isTrue);
|
|
expect(pressedKeys, equals(<LogicalKeyboardKey>[LogicalKeyboardKey.shiftLeft]));
|
|
});
|
|
|
|
testWidgets('Shortcuts.manager lets manager handle shortcuts', (WidgetTester tester) async {
|
|
final GlobalKey containerKey = GlobalKey();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.shift): const TestIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
bool invoked = false;
|
|
await tester.pumpWidget(
|
|
Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invoked = true;
|
|
return true;
|
|
},
|
|
),
|
|
},
|
|
child: Shortcuts.manager(
|
|
manager: testManager,
|
|
child: Focus(
|
|
autofocus: true,
|
|
child: SizedBox(key: containerKey, width: 100, height: 100),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, isTrue);
|
|
expect(pressedKeys, equals(<LogicalKeyboardKey>[LogicalKeyboardKey.shiftLeft]));
|
|
});
|
|
|
|
testWidgets('ShortcutManager ignores key presses with no primary focus', (WidgetTester tester) async {
|
|
final GlobalKey containerKey = GlobalKey();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.shift): const TestIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
bool invoked = false;
|
|
await tester.pumpWidget(
|
|
Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invoked = true;
|
|
return true;
|
|
},
|
|
),
|
|
},
|
|
child: Shortcuts.manager(
|
|
manager: testManager,
|
|
child: SizedBox(key: containerKey, width: 100, height: 100),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
expect(primaryFocus, isNull);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, isFalse);
|
|
expect(pressedKeys, isEmpty);
|
|
});
|
|
|
|
test('$ShortcutManager dispatches object creation in constructor', () async {
|
|
await expectLater(
|
|
await memoryEvents(() => ShortcutManager().dispose(), ShortcutManager),
|
|
areCreateAndDispose,
|
|
);
|
|
});
|
|
|
|
testWidgets("Shortcuts passes to the next Shortcuts widget if it doesn't map the key", (WidgetTester tester) async {
|
|
final GlobalKey containerKey = GlobalKey();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.shift): const TestIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
bool invoked = false;
|
|
await tester.pumpWidget(
|
|
Shortcuts.manager(
|
|
manager: testManager,
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invoked = true;
|
|
return invoked;
|
|
},
|
|
),
|
|
},
|
|
child: Shortcuts(
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.keyA): Intent.doNothing,
|
|
},
|
|
child: Focus(
|
|
autofocus: true,
|
|
child: SizedBox(key: containerKey, width: 100, height: 100),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, isTrue);
|
|
expect(pressedKeys, equals(<LogicalKeyboardKey>[LogicalKeyboardKey.shiftLeft]));
|
|
});
|
|
|
|
testWidgets('Shortcuts can disable a shortcut with Intent.doNothing', (WidgetTester tester) async {
|
|
final GlobalKey containerKey = GlobalKey();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.shift): const TestIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
bool invoked = false;
|
|
await tester.pumpWidget(
|
|
MaterialApp(
|
|
home: Shortcuts.manager(
|
|
manager: testManager,
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invoked = true;
|
|
return invoked;
|
|
},
|
|
),
|
|
},
|
|
child: Shortcuts(
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.shift): Intent.doNothing,
|
|
},
|
|
child: Focus(
|
|
autofocus: true,
|
|
child: SizedBox(key: containerKey, width: 100, height: 100),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, isFalse);
|
|
expect(pressedKeys, isEmpty);
|
|
});
|
|
|
|
testWidgets("Shortcuts that aren't bound to an action don't absorb keys meant for text fields", (WidgetTester tester) async {
|
|
final GlobalKey textFieldKey = GlobalKey();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.keyA): const TestIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
await tester.pumpWidget(
|
|
MaterialApp(
|
|
home: Material(
|
|
child: Shortcuts.manager(
|
|
manager: testManager,
|
|
child: TextField(key: textFieldKey, autofocus: true),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
final bool handled = await tester.sendKeyEvent(LogicalKeyboardKey.keyA);
|
|
expect(handled, isFalse);
|
|
expect(pressedKeys, equals(<LogicalKeyboardKey>[LogicalKeyboardKey.keyA]));
|
|
});
|
|
|
|
testWidgets('Shortcuts that are bound to an action do override text fields', (WidgetTester tester) async {
|
|
final GlobalKey textFieldKey = GlobalKey();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.keyA): const TestIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
bool invoked = false;
|
|
await tester.pumpWidget(
|
|
MaterialApp(
|
|
home: Material(
|
|
child: Shortcuts.manager(
|
|
manager: testManager,
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invoked = true;
|
|
return invoked;
|
|
},
|
|
),
|
|
},
|
|
child: TextField(key: textFieldKey, autofocus: true),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
final bool result = await tester.sendKeyEvent(LogicalKeyboardKey.keyA);
|
|
expect(result, isTrue);
|
|
expect(pressedKeys, equals(<LogicalKeyboardKey>[LogicalKeyboardKey.keyA]));
|
|
expect(invoked, isTrue);
|
|
});
|
|
|
|
testWidgets('Shortcuts can override intents that apply to text fields', (WidgetTester tester) async {
|
|
final GlobalKey textFieldKey = GlobalKey();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.keyA): const TestIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
bool invoked = false;
|
|
await tester.pumpWidget(
|
|
MaterialApp(
|
|
home: Material(
|
|
child: Shortcuts.manager(
|
|
manager: testManager,
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invoked = true;
|
|
return invoked;
|
|
},
|
|
),
|
|
},
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: DoNothingAction(consumesKey: false),
|
|
},
|
|
child: TextField(key: textFieldKey, autofocus: true),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
final bool result = await tester.sendKeyEvent(LogicalKeyboardKey.keyA);
|
|
expect(result, isFalse);
|
|
expect(invoked, isFalse);
|
|
});
|
|
|
|
testWidgets('Shortcuts can override intents that apply to text fields with DoNothingAndStopPropagationIntent', (WidgetTester tester) async {
|
|
final GlobalKey textFieldKey = GlobalKey();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.keyA): const TestIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
bool invoked = false;
|
|
await tester.pumpWidget(
|
|
MaterialApp(
|
|
home: Material(
|
|
child: Shortcuts.manager(
|
|
manager: testManager,
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invoked = true;
|
|
return invoked;
|
|
},
|
|
),
|
|
},
|
|
child: Shortcuts(
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.keyA): const DoNothingAndStopPropagationIntent(),
|
|
},
|
|
child: TextField(key: textFieldKey, autofocus: true),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
final bool result = await tester.sendKeyEvent(LogicalKeyboardKey.keyA);
|
|
expect(result, isFalse);
|
|
expect(invoked, isFalse);
|
|
});
|
|
|
|
test('Shortcuts diagnostics work.', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
Shortcuts(
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(
|
|
LogicalKeyboardKey.shift,
|
|
LogicalKeyboardKey.keyA,
|
|
): const ActivateIntent(),
|
|
LogicalKeySet(
|
|
LogicalKeyboardKey.shift,
|
|
LogicalKeyboardKey.arrowRight,
|
|
): const DirectionalFocusIntent(TraversalDirection.right),
|
|
},
|
|
child: const SizedBox(),
|
|
).debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(1));
|
|
expect(
|
|
description[0],
|
|
equalsIgnoringHashCodes(
|
|
'shortcuts: {{Shift + Key A}: ActivateIntent#00000, {Shift + Arrow Right}: DirectionalFocusIntent#00000(direction: right)}',
|
|
),
|
|
);
|
|
});
|
|
|
|
test('Shortcuts diagnostics work when debugLabel specified.', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
Shortcuts(
|
|
debugLabel: '<Debug Label>',
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
): const ActivateIntent(),
|
|
},
|
|
child: const SizedBox(),
|
|
).debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(1));
|
|
expect(description[0], equals('shortcuts: <Debug Label>'));
|
|
});
|
|
|
|
test('Shortcuts diagnostics work when manager not specified.', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
Shortcuts(
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
): const ActivateIntent(),
|
|
},
|
|
child: const SizedBox(),
|
|
).debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(1));
|
|
expect(description[0], equalsIgnoringHashCodes('shortcuts: {{Key A + Key B}: ActivateIntent#00000}'));
|
|
});
|
|
|
|
test('Shortcuts diagnostics work when manager specified.', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
final List<LogicalKeyboardKey> pressedKeys = <LogicalKeyboardKey>[];
|
|
final TestShortcutManager testManager = TestShortcutManager(
|
|
pressedKeys,
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(
|
|
LogicalKeyboardKey.keyA,
|
|
LogicalKeyboardKey.keyB,
|
|
): const ActivateIntent(),
|
|
},
|
|
);
|
|
addTearDown(testManager.dispose);
|
|
|
|
Shortcuts.manager(
|
|
manager: testManager,
|
|
child: const SizedBox(),
|
|
).debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(2));
|
|
expect(description[0], equalsIgnoringHashCodes('manager: TestShortcutManager#00000(shortcuts: {LogicalKeySet#00000(keys: Key A + Key B): ActivateIntent#00000})'));
|
|
expect(description[1], equalsIgnoringHashCodes('shortcuts: {{Key A + Key B}: ActivateIntent#00000}'));
|
|
});
|
|
|
|
testWidgets('Shortcuts support multiple intents', (WidgetTester tester) async {
|
|
tester.binding.focusManager.highlightStrategy = FocusHighlightStrategy.alwaysTraditional;
|
|
bool? value = true;
|
|
Widget buildApp() {
|
|
return MaterialApp(
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.space): const PrioritizedIntents(
|
|
orderedIntents: <Intent>[
|
|
ActivateIntent(),
|
|
ScrollIntent(direction: AxisDirection.down, type: ScrollIncrementType.page),
|
|
],
|
|
),
|
|
LogicalKeySet(LogicalKeyboardKey.tab): const NextFocusIntent(),
|
|
LogicalKeySet(LogicalKeyboardKey.pageUp): const ScrollIntent(direction: AxisDirection.up, type: ScrollIncrementType.page),
|
|
},
|
|
home: Material(
|
|
child: Center(
|
|
child: ListView(
|
|
primary: true,
|
|
children: <Widget> [
|
|
StatefulBuilder(
|
|
builder: (BuildContext context, StateSetter setState) {
|
|
return Checkbox(
|
|
value: value,
|
|
onChanged: (bool? newValue) => setState(() { value = newValue; }),
|
|
focusColor: Colors.orange[500],
|
|
);
|
|
},
|
|
),
|
|
Container(
|
|
color: Colors.blue,
|
|
height: 1000,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
await tester.pumpWidget(buildApp());
|
|
await tester.pumpAndSettle();
|
|
expect(
|
|
tester.binding.focusManager.primaryFocus!.toStringShort(),
|
|
equalsIgnoringHashCodes('FocusScopeNode#00000(_ModalScopeState<dynamic> Focus Scope [PRIMARY FOCUS])'),
|
|
);
|
|
final ScrollController controller = PrimaryScrollController.of(
|
|
tester.element(find.byType(ListView)),
|
|
);
|
|
expect(controller.position.pixels, 0.0);
|
|
expect(value, isTrue);
|
|
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.space);
|
|
await tester.pumpAndSettle();
|
|
// ScrollView scrolls
|
|
expect(controller.position.pixels, 448.0);
|
|
expect(value, isTrue);
|
|
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.pageUp);
|
|
await tester.pumpAndSettle();
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.tab);
|
|
await tester.pumpAndSettle();
|
|
// Focus is now on the checkbox.
|
|
expect(
|
|
tester.binding.focusManager.primaryFocus!.toStringShort(),
|
|
equalsIgnoringHashCodes('FocusNode#00000([PRIMARY FOCUS])'),
|
|
);
|
|
expect(value, isTrue);
|
|
expect(controller.position.pixels, 0.0);
|
|
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.space);
|
|
await tester.pumpAndSettle();
|
|
// Checkbox is toggled, scroll view does not scroll.
|
|
expect(value, isFalse);
|
|
expect(controller.position.pixels, 0.0);
|
|
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.space);
|
|
await tester.pumpAndSettle();
|
|
expect(value, isTrue);
|
|
expect(controller.position.pixels, 0.0);
|
|
});
|
|
|
|
testWidgets('Shortcuts support activators that returns null in triggers', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
const DumbLogicalActivator(LogicalKeyboardKey.keyC),
|
|
(Intent intent) { invoked += 1; },
|
|
const SingleActivator(LogicalKeyboardKey.keyC, control: true),
|
|
(Intent intent) { invoked += 10; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// Press KeyC: Accepted by DumbLogicalActivator
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// Press ControlLeft + KeyC: Accepted by SingleActivator
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 10);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 10);
|
|
invoked = 0;
|
|
|
|
// Press ControlLeft + ShiftLeft + KeyC: Accepted by DumbLogicalActivator
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyC);
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyC);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
});
|
|
|
|
testWidgets('Shortcuts does not insert a semantics node when includeSemantics is false', (WidgetTester tester) async {
|
|
final SemanticsTester semanticsTester = SemanticsTester(tester);
|
|
addTearDown(semanticsTester.dispose);
|
|
|
|
// By default, includeSemantics is true.
|
|
await tester.pumpWidget(
|
|
const Shortcuts(
|
|
shortcuts: <LogicalKeySet, Intent>{},
|
|
child: SizedBox(),
|
|
),
|
|
);
|
|
|
|
expect(
|
|
semanticsTester,
|
|
hasSemantics(
|
|
TestSemantics.root(
|
|
children: <TestSemantics>[
|
|
TestSemantics(id: 1),
|
|
],
|
|
),
|
|
ignoreRect: true,
|
|
ignoreTransform: true,
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
const Shortcuts(
|
|
includeSemantics: false,
|
|
shortcuts: <LogicalKeySet, Intent>{},
|
|
child: SizedBox(),
|
|
),
|
|
);
|
|
|
|
expect(
|
|
semanticsTester,
|
|
hasSemantics(
|
|
TestSemantics.root(),
|
|
ignoreRect: true,
|
|
ignoreTransform: true,
|
|
),
|
|
);
|
|
|
|
semanticsTester.dispose();
|
|
});
|
|
});
|
|
|
|
group('CharacterActivator', () {
|
|
testWidgets('is triggered on events with correct character', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
const CharacterActivator('?'),
|
|
(Intent intent) { invoked += 1; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// Press Shift + /
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.slash, character: '?');
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.slash);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
}, variant: KeySimulatorTransitModeVariant.all());
|
|
|
|
testWidgets('handles repeated events', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
const CharacterActivator('?'),
|
|
(Intent intent) { invoked += 1; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// Press KeyC: Accepted by DumbLogicalActivator
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.slash, character: '?');
|
|
expect(invoked, 1);
|
|
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.slash, character: '?');
|
|
expect(invoked, 2);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.slash);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 2);
|
|
invoked = 0;
|
|
}, variant: KeySimulatorTransitModeVariant.all());
|
|
|
|
testWidgets('rejects repeated events if requested', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
const CharacterActivator('?', includeRepeats: false),
|
|
(Intent intent) { invoked += 1; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// Press Shift + /
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.slash, character: '?');
|
|
expect(invoked, 1);
|
|
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.slash, character: '?');
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.slash);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
}, variant: KeySimulatorTransitModeVariant.all());
|
|
|
|
testWidgets('handles Alt, Ctrl and Meta', (WidgetTester tester) async {
|
|
int invoked = 0;
|
|
await tester.pumpWidget(activatorTester(
|
|
const CharacterActivator('?', alt: true, meta: true, control: true),
|
|
(Intent intent) { invoked += 1; },
|
|
));
|
|
await tester.pump();
|
|
|
|
// Press Shift + /
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.slash, character: '?');
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.slash);
|
|
expect(invoked, 0);
|
|
|
|
// Press Left Alt + Ctrl + Meta + Shift + /
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.altLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.metaLeft);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.slash, character: '?');
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.slash);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.metaLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.altLeft);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
|
|
// Press Right Alt + Ctrl + Meta + Shift + /
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftRight);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.altRight);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.metaRight);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlRight);
|
|
expect(invoked, 0);
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.slash, character: '?');
|
|
expect(invoked, 1);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.slash);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftRight);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.metaRight);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.altRight);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlRight);
|
|
expect(invoked, 1);
|
|
invoked = 0;
|
|
}, variant: KeySimulatorTransitModeVariant.all());
|
|
|
|
testWidgets('isActivatedBy works as expected', (WidgetTester tester) async {
|
|
// Collect some key events to use for testing.
|
|
final List<KeyEvent> events = <KeyEvent>[];
|
|
await tester.pumpWidget(
|
|
Focus(
|
|
autofocus: true,
|
|
onKeyEvent: (FocusNode node, KeyEvent event) {
|
|
events.add(event);
|
|
return KeyEventResult.ignored;
|
|
},
|
|
child: const SizedBox(),
|
|
),
|
|
);
|
|
|
|
const CharacterActivator characterActivator = CharacterActivator('a');
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(characterActivator, events.last), isTrue);
|
|
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(characterActivator, events.last), isTrue);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(characterActivator, events.last), isFalse);
|
|
|
|
const CharacterActivator noRepeatCharacterActivator = CharacterActivator('a', includeRepeats: false);
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(noRepeatCharacterActivator, events.last), isTrue);
|
|
await tester.sendKeyRepeatEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(noRepeatCharacterActivator, events.last), isFalse);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(ShortcutActivator.isActivatedBy(noRepeatCharacterActivator, events.last), isFalse);
|
|
});
|
|
|
|
group('diagnostics.', () {
|
|
test('single key', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
const CharacterActivator('A').debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(1));
|
|
expect(description[0], equals("character: 'A'"));
|
|
});
|
|
|
|
test('no repeats', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
const CharacterActivator('A', includeRepeats: false)
|
|
.debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(2));
|
|
expect(description[0], equals("character: 'A'"));
|
|
expect(description[1], equals('excluding repeats'));
|
|
});
|
|
|
|
test('combination', () {
|
|
final DiagnosticPropertiesBuilder builder = DiagnosticPropertiesBuilder();
|
|
|
|
const CharacterActivator('A',
|
|
control: true,
|
|
meta: true,
|
|
).debugFillProperties(builder);
|
|
|
|
final List<String> description = builder.properties.where((DiagnosticsNode node) {
|
|
return !node.isFiltered(DiagnosticLevel.info);
|
|
}).map((DiagnosticsNode node) => node.toString()).toList();
|
|
|
|
expect(description.length, equals(1));
|
|
expect(description[0], equals("character: Control + Meta + 'A'"));
|
|
});
|
|
});
|
|
});
|
|
|
|
group('CallbackShortcuts', () {
|
|
testWidgets('trigger on key events', (WidgetTester tester) async {
|
|
int invokedA = 0;
|
|
int invokedB = 0;
|
|
await tester.pumpWidget(
|
|
CallbackShortcuts(
|
|
bindings: <ShortcutActivator, VoidCallback>{
|
|
const SingleActivator(LogicalKeyboardKey.keyA): () {
|
|
invokedA += 1;
|
|
},
|
|
const SingleActivator(LogicalKeyboardKey.keyB): () {
|
|
invokedB += 1;
|
|
},
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
await tester.pump();
|
|
expect(invokedA, equals(1));
|
|
expect(invokedB, equals(0));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedA, equals(1));
|
|
expect(invokedB, equals(0));
|
|
invokedA = 0;
|
|
invokedB = 0;
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedA, equals(0));
|
|
expect(invokedB, equals(1));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedA, equals(0));
|
|
expect(invokedB, equals(1));
|
|
});
|
|
|
|
testWidgets('nested CallbackShortcuts stop propagation', (WidgetTester tester) async {
|
|
int invokedOuter = 0;
|
|
int invokedInner = 0;
|
|
await tester.pumpWidget(
|
|
CallbackShortcuts(
|
|
bindings: <ShortcutActivator, VoidCallback>{
|
|
const SingleActivator(LogicalKeyboardKey.keyA): () {
|
|
invokedOuter += 1;
|
|
},
|
|
},
|
|
child: CallbackShortcuts(
|
|
bindings: <ShortcutActivator, VoidCallback>{
|
|
const SingleActivator(LogicalKeyboardKey.keyA): () {
|
|
invokedInner += 1;
|
|
},
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedOuter, equals(0));
|
|
expect(invokedInner, equals(1));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedOuter, equals(0));
|
|
expect(invokedInner, equals(1));
|
|
});
|
|
|
|
testWidgets('non-overlapping nested CallbackShortcuts fire appropriately', (WidgetTester tester) async {
|
|
int invokedOuter = 0;
|
|
int invokedInner = 0;
|
|
await tester.pumpWidget(
|
|
CallbackShortcuts(
|
|
bindings: <ShortcutActivator, VoidCallback>{
|
|
const CharacterActivator('b'): () {
|
|
invokedOuter += 1;
|
|
},
|
|
},
|
|
child: CallbackShortcuts(
|
|
bindings: <ShortcutActivator, VoidCallback>{
|
|
const CharacterActivator('a'): () {
|
|
invokedInner += 1;
|
|
},
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedOuter, equals(0));
|
|
expect(invokedInner, equals(1));
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedOuter, equals(1));
|
|
expect(invokedInner, equals(1));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedOuter, equals(1));
|
|
expect(invokedInner, equals(1));
|
|
});
|
|
|
|
testWidgets('Works correctly with Shortcuts too', (WidgetTester tester) async {
|
|
int invokedCallbackA = 0;
|
|
int invokedCallbackB = 0;
|
|
int invokedActionA = 0;
|
|
int invokedActionB = 0;
|
|
|
|
void clear() {
|
|
invokedCallbackA = 0;
|
|
invokedCallbackB = 0;
|
|
invokedActionA = 0;
|
|
invokedActionB = 0;
|
|
}
|
|
|
|
await tester.pumpWidget(
|
|
Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invokedActionA += 1;
|
|
return true;
|
|
},
|
|
),
|
|
TestIntent2: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invokedActionB += 1;
|
|
return true;
|
|
},
|
|
),
|
|
},
|
|
child: CallbackShortcuts(
|
|
bindings: <ShortcutActivator, VoidCallback>{
|
|
const CharacterActivator('b'): () {
|
|
invokedCallbackB += 1;
|
|
},
|
|
},
|
|
child: Shortcuts(
|
|
shortcuts: <LogicalKeySet, Intent>{
|
|
LogicalKeySet(LogicalKeyboardKey.keyA): const TestIntent(),
|
|
LogicalKeySet(LogicalKeyboardKey.keyB): const TestIntent2(),
|
|
},
|
|
child: CallbackShortcuts(
|
|
bindings: <ShortcutActivator, VoidCallback>{
|
|
const CharacterActivator('a'): () {
|
|
invokedCallbackA += 1;
|
|
},
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedCallbackA, equals(1));
|
|
expect(invokedCallbackB, equals(0));
|
|
expect(invokedActionA, equals(0));
|
|
expect(invokedActionB, equals(0));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
clear();
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedCallbackA, equals(0));
|
|
expect(invokedCallbackB, equals(0));
|
|
expect(invokedActionA, equals(0));
|
|
expect(invokedActionB, equals(1));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyB);
|
|
});
|
|
});
|
|
|
|
group('ShortcutRegistrar', () {
|
|
testWidgets('trigger ShortcutRegistrar on key events', (WidgetTester tester) async {
|
|
int invokedA = 0;
|
|
int invokedB = 0;
|
|
await tester.pumpWidget(
|
|
ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
shortcuts: <ShortcutActivator, Intent>{
|
|
const SingleActivator(LogicalKeyboardKey.keyA): VoidCallbackIntent(() {
|
|
invokedA += 1;
|
|
}),
|
|
const SingleActivator(LogicalKeyboardKey.keyB): VoidCallbackIntent(() {
|
|
invokedB += 1;
|
|
}),
|
|
},
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
VoidCallbackIntent: VoidCallbackAction(),
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
await tester.pump();
|
|
expect(invokedA, equals(1));
|
|
expect(invokedB, equals(0));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedA, equals(1));
|
|
expect(invokedB, equals(0));
|
|
invokedA = 0;
|
|
invokedB = 0;
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedA, equals(0));
|
|
expect(invokedB, equals(1));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedA, equals(0));
|
|
expect(invokedB, equals(1));
|
|
});
|
|
|
|
testWidgets('MaterialApp has a ShortcutRegistrar listening', (WidgetTester tester) async {
|
|
int invokedA = 0;
|
|
int invokedB = 0;
|
|
await tester.pumpWidget(
|
|
MaterialApp(
|
|
home: TestCallbackRegistration(
|
|
shortcuts: <ShortcutActivator, Intent>{
|
|
const SingleActivator(LogicalKeyboardKey.keyA): VoidCallbackIntent(() {
|
|
invokedA += 1;
|
|
}),
|
|
const SingleActivator(LogicalKeyboardKey.keyB): VoidCallbackIntent(() {
|
|
invokedB += 1;
|
|
}),
|
|
},
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
VoidCallbackIntent: VoidCallbackAction(),
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
await tester.pump();
|
|
expect(invokedA, equals(1));
|
|
expect(invokedB, equals(0));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedA, equals(1));
|
|
expect(invokedB, equals(0));
|
|
invokedA = 0;
|
|
invokedB = 0;
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedA, equals(0));
|
|
expect(invokedB, equals(1));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedA, equals(0));
|
|
expect(invokedB, equals(1));
|
|
});
|
|
|
|
testWidgets("doesn't override text field shortcuts", (WidgetTester tester) async {
|
|
final TextEditingController controller = TextEditingController();
|
|
addTearDown(controller.dispose);
|
|
await tester.pumpWidget(
|
|
MaterialApp(
|
|
home: Scaffold(
|
|
body: ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
shortcuts: const <ShortcutActivator, Intent>{
|
|
SingleActivator(LogicalKeyboardKey.keyA, control: true): SelectAllTextIntent(SelectionChangedCause.keyboard),
|
|
},
|
|
child: TextField(
|
|
autofocus: true,
|
|
controller: controller,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
controller.text = 'Testing';
|
|
await tester.pump();
|
|
|
|
// Send a "Ctrl-A", which should be bound to select all by default.
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.sendKeyEvent(LogicalKeyboardKey.keyA);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
|
|
await tester.pump();
|
|
|
|
expect(controller.selection.baseOffset, equals(0));
|
|
expect(controller.selection.extentOffset, equals(7));
|
|
});
|
|
|
|
testWidgets('nested ShortcutRegistrars stop propagation', (WidgetTester tester) async {
|
|
int invokedOuter = 0;
|
|
int invokedInner = 0;
|
|
await tester.pumpWidget(
|
|
ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
shortcuts: <ShortcutActivator, Intent>{
|
|
const SingleActivator(LogicalKeyboardKey.keyA): VoidCallbackIntent(() {
|
|
invokedOuter += 1;
|
|
}),
|
|
},
|
|
child: ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
shortcuts: <ShortcutActivator, Intent>{
|
|
const SingleActivator(LogicalKeyboardKey.keyA): VoidCallbackIntent(() {
|
|
invokedInner += 1;
|
|
}),
|
|
},
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
VoidCallbackIntent: VoidCallbackAction(),
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedOuter, equals(0));
|
|
expect(invokedInner, equals(1));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedOuter, equals(0));
|
|
expect(invokedInner, equals(1));
|
|
});
|
|
|
|
testWidgets('non-overlapping nested ShortcutRegistrars fire appropriately', (WidgetTester tester) async {
|
|
int invokedOuter = 0;
|
|
int invokedInner = 0;
|
|
await tester.pumpWidget(
|
|
ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
shortcuts: <ShortcutActivator, Intent>{
|
|
const CharacterActivator('b'): VoidCallbackIntent(() {
|
|
invokedOuter += 1;
|
|
}),
|
|
},
|
|
child: ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
shortcuts: <ShortcutActivator, Intent>{
|
|
const CharacterActivator('a'): VoidCallbackIntent(() {
|
|
invokedInner += 1;
|
|
}),
|
|
},
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
VoidCallbackIntent: VoidCallbackAction(),
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedOuter, equals(0));
|
|
expect(invokedInner, equals(1));
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedOuter, equals(1));
|
|
expect(invokedInner, equals(1));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedOuter, equals(1));
|
|
expect(invokedInner, equals(1));
|
|
});
|
|
|
|
testWidgets('Works correctly with Shortcuts too', (WidgetTester tester) async {
|
|
int invokedCallbackA = 0;
|
|
int invokedCallbackB = 0;
|
|
int invokedActionA = 0;
|
|
int invokedActionB = 0;
|
|
|
|
void clear() {
|
|
invokedCallbackA = 0;
|
|
invokedCallbackB = 0;
|
|
invokedActionA = 0;
|
|
invokedActionB = 0;
|
|
}
|
|
|
|
await tester.pumpWidget(
|
|
Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invokedActionA += 1;
|
|
return true;
|
|
},
|
|
),
|
|
TestIntent2: TestAction(
|
|
onInvoke: (Intent intent) {
|
|
invokedActionB += 1;
|
|
return true;
|
|
},
|
|
),
|
|
VoidCallbackIntent: VoidCallbackAction(),
|
|
},
|
|
child: ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
shortcuts: <ShortcutActivator, Intent>{
|
|
const CharacterActivator('b'): VoidCallbackIntent(() {
|
|
invokedCallbackB += 1;
|
|
}),
|
|
},
|
|
child: Shortcuts(
|
|
shortcuts: const <ShortcutActivator, Intent>{
|
|
SingleActivator(LogicalKeyboardKey.keyA): TestIntent(),
|
|
SingleActivator(LogicalKeyboardKey.keyB): TestIntent2(),
|
|
},
|
|
child: ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
shortcuts: <ShortcutActivator, Intent>{
|
|
const CharacterActivator('a'): VoidCallbackIntent(() {
|
|
invokedCallbackA += 1;
|
|
}),
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pump();
|
|
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyA);
|
|
expect(invokedCallbackA, equals(1));
|
|
expect(invokedCallbackB, equals(0));
|
|
expect(invokedActionA, equals(0));
|
|
expect(invokedActionB, equals(0));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyA);
|
|
clear();
|
|
await tester.sendKeyDownEvent(LogicalKeyboardKey.keyB);
|
|
expect(invokedCallbackA, equals(0));
|
|
expect(invokedCallbackB, equals(0));
|
|
expect(invokedActionA, equals(0));
|
|
expect(invokedActionB, equals(1));
|
|
await tester.sendKeyUpEvent(LogicalKeyboardKey.keyB);
|
|
});
|
|
|
|
testWidgets('Updating shortcuts triggers dependency rebuild', (WidgetTester tester) async {
|
|
final List<Map<ShortcutActivator, Intent>> shortcutsChanged = <Map<ShortcutActivator, Intent>>[];
|
|
void dependenciesUpdated(Map<ShortcutActivator, Intent> shortcuts) {
|
|
shortcutsChanged.add(shortcuts);
|
|
}
|
|
await tester.pumpWidget(
|
|
ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
onDependencyUpdate: dependenciesUpdated,
|
|
shortcuts: const <ShortcutActivator, Intent>{
|
|
SingleActivator(LogicalKeyboardKey.keyA): SelectAllTextIntent(SelectionChangedCause.keyboard),
|
|
SingleActivator(LogicalKeyboardKey.keyB): ActivateIntent(),
|
|
},
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
VoidCallbackIntent: VoidCallbackAction(),
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
onDependencyUpdate: dependenciesUpdated,
|
|
shortcuts: const <ShortcutActivator, Intent>{
|
|
SingleActivator(LogicalKeyboardKey.keyA): SelectAllTextIntent(SelectionChangedCause.keyboard),
|
|
},
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
VoidCallbackIntent: VoidCallbackAction(),
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
await tester.pumpWidget(
|
|
ShortcutRegistrar(
|
|
child: TestCallbackRegistration(
|
|
onDependencyUpdate: dependenciesUpdated,
|
|
shortcuts: const <ShortcutActivator, Intent>{
|
|
SingleActivator(LogicalKeyboardKey.keyA): SelectAllTextIntent(SelectionChangedCause.keyboard),
|
|
SingleActivator(LogicalKeyboardKey.keyB): ActivateIntent(),
|
|
},
|
|
child: Actions(
|
|
actions: <Type, Action<Intent>>{
|
|
VoidCallbackIntent: VoidCallbackAction(),
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: Placeholder(),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
expect(shortcutsChanged.length, equals(2));
|
|
expect(shortcutsChanged.last, equals(const <ShortcutActivator, Intent>{
|
|
SingleActivator(LogicalKeyboardKey.keyA): SelectAllTextIntent(SelectionChangedCause.keyboard),
|
|
SingleActivator(LogicalKeyboardKey.keyB): ActivateIntent(),
|
|
}));
|
|
});
|
|
|
|
testWidgets('using a disposed token asserts', (WidgetTester tester) async {
|
|
final ShortcutRegistry registry = ShortcutRegistry();
|
|
addTearDown(registry.dispose);
|
|
final ShortcutRegistryEntry token = registry.addAll(const <ShortcutActivator, Intent>{
|
|
SingleActivator(LogicalKeyboardKey.keyA): DoNothingIntent(),
|
|
});
|
|
token.dispose();
|
|
expect(() {token.replaceAll(<ShortcutActivator, Intent>{}); }, throwsFlutterError);
|
|
});
|
|
|
|
testWidgets('setting duplicate bindings asserts', (WidgetTester tester) async {
|
|
final ShortcutRegistry registry = ShortcutRegistry();
|
|
addTearDown(registry.dispose);
|
|
final ShortcutRegistryEntry token = registry.addAll(const <ShortcutActivator, Intent>{
|
|
SingleActivator(LogicalKeyboardKey.keyA): DoNothingIntent(),
|
|
});
|
|
expect(() {
|
|
final ShortcutRegistryEntry token2 = registry.addAll(const <ShortcutActivator, Intent>{
|
|
SingleActivator(LogicalKeyboardKey.keyA): ActivateIntent(),
|
|
});
|
|
token2.dispose();
|
|
}, throwsAssertionError);
|
|
token.dispose();
|
|
});
|
|
|
|
test('dispatches object creation in constructor', () async {
|
|
await expectLater(
|
|
await memoryEvents(() => ShortcutRegistry().dispose(), ShortcutRegistry),
|
|
areCreateAndDispose,
|
|
);
|
|
});
|
|
});
|
|
}
|
|
|
|
class TestCallbackRegistration extends StatefulWidget {
|
|
const TestCallbackRegistration({super.key, required this.shortcuts, this.onDependencyUpdate, required this.child});
|
|
|
|
final Map<ShortcutActivator, Intent> shortcuts;
|
|
final void Function(Map<ShortcutActivator, Intent> shortcuts)? onDependencyUpdate;
|
|
final Widget child;
|
|
|
|
@override
|
|
State<TestCallbackRegistration> createState() => _TestCallbackRegistrationState();
|
|
}
|
|
|
|
class _TestCallbackRegistrationState extends State<TestCallbackRegistration> {
|
|
ShortcutRegistryEntry? _registryToken;
|
|
|
|
@override
|
|
void didChangeDependencies() {
|
|
super.didChangeDependencies();
|
|
_registryToken?.dispose();
|
|
_registryToken = ShortcutRegistry.of(context).addAll(widget.shortcuts);
|
|
}
|
|
|
|
@override
|
|
void didUpdateWidget(TestCallbackRegistration oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
if (widget.shortcuts != oldWidget.shortcuts || _registryToken == null) {
|
|
_registryToken?.dispose();
|
|
_registryToken = ShortcutRegistry.of(context).addAll(widget.shortcuts);
|
|
}
|
|
widget.onDependencyUpdate?.call(ShortcutRegistry.of(context).shortcuts);
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_registryToken?.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return widget.child;
|
|
}
|
|
}
|
|
|
|
class TestAction extends CallbackAction<Intent> {
|
|
TestAction({
|
|
required super.onInvoke,
|
|
});
|
|
}
|
|
|
|
/// An activator that accepts down events that has [key] as the logical key.
|
|
///
|
|
/// This class is used only to tests. It is intentionally designed poorly by
|
|
/// returning null in [triggers], and checks [key] in [accepts].
|
|
class DumbLogicalActivator extends ShortcutActivator {
|
|
const DumbLogicalActivator(this.key);
|
|
|
|
final LogicalKeyboardKey key;
|
|
|
|
@override
|
|
Iterable<LogicalKeyboardKey>? get triggers => null;
|
|
|
|
@override
|
|
bool accepts(KeyEvent event, HardwareKeyboard state) {
|
|
return (event is KeyDownEvent || event is KeyRepeatEvent)
|
|
&& event.logicalKey == key;
|
|
}
|
|
|
|
/// Returns a short and readable description of the key combination.
|
|
///
|
|
/// Intended to be used in debug mode for logging purposes. In release mode,
|
|
/// [debugDescribeKeys] returns an empty string.
|
|
@override
|
|
String debugDescribeKeys() {
|
|
String result = '';
|
|
assert(() {
|
|
result = key.keyLabel;
|
|
return true;
|
|
}());
|
|
return result;
|
|
}
|
|
}
|
|
|
|
class TestIntent extends Intent {
|
|
const TestIntent();
|
|
}
|
|
|
|
class TestIntent2 extends Intent {
|
|
const TestIntent2();
|
|
}
|
|
|
|
class TestShortcutManager extends ShortcutManager {
|
|
TestShortcutManager(this.keys, { super.shortcuts });
|
|
|
|
List<LogicalKeyboardKey> keys;
|
|
|
|
@override
|
|
KeyEventResult handleKeypress(BuildContext context, KeyEvent event) {
|
|
if (event is KeyDownEvent || event is KeyRepeatEvent) {
|
|
keys.add(event.logicalKey);
|
|
}
|
|
return super.handleKeypress(context, event);
|
|
}
|
|
}
|
|
|
|
Widget activatorTester(
|
|
ShortcutActivator activator,
|
|
ValueSetter<Intent> onInvoke, [
|
|
ShortcutActivator? activator2,
|
|
ValueSetter<Intent>? onInvoke2,
|
|
]) {
|
|
final bool hasSecond = activator2 != null && onInvoke2 != null;
|
|
return Actions(
|
|
key: GlobalKey(),
|
|
actions: <Type, Action<Intent>>{
|
|
TestIntent: TestAction(onInvoke: (Intent intent) {
|
|
onInvoke(intent);
|
|
return true;
|
|
}),
|
|
if (hasSecond)
|
|
TestIntent2: TestAction(onInvoke: (Intent intent) {
|
|
onInvoke2(intent);
|
|
return null;
|
|
}),
|
|
},
|
|
child: Shortcuts(
|
|
shortcuts: <ShortcutActivator, Intent>{
|
|
activator: const TestIntent(),
|
|
if (hasSecond)
|
|
activator2: const TestIntent2(),
|
|
},
|
|
child: const Focus(
|
|
autofocus: true,
|
|
child: SizedBox(width: 100, height: 100),
|
|
),
|
|
),
|
|
);
|
|
}
|