LayoutCallback passes constraints to the callback, but the constraints
object has a different type for different subclasses. This lets you
call invokeLayoutCallback() with a specific type to verify that
everything is working as expected.
Other changes:
Slightly improve the error reporting in RenderObject.
Allow toStringShallow on RenderObject to have its separator configured.
More idiomatic use of constraints in performResize.
Trivial fixes to comments.
Make ProxyBox not use BoxParentData since it ignores the field.
Make applyPaintTransform more helpful if you use a different ParentData
subclass than RenderBox expects.
Make debugAssertIsValid actually fulfill its contract in RenderObject as
documented.
Add a childBefore for symmetry (we already had childAfter).
Fix the way we dump the child list when there's no children in a
multichild render object.
More asserts in the rendering test library.
We weren't computing the bounds for composited transforms correctly. We
need to conjugate the transform by the offset in order to get the
correct paint bounds for the composited layer. We now also use the same
math in the non-composited case for consistency.
Also, don't scale the z-coordinate in RenderFittedBox.
Fixes#6293
This patch removes the Mozart dependencies from object.dart and
layer.dart, which will make it easier for us to move the Mozart
dependencies purely into the Fuchsia tree.
This rewrites imports of various mojom.dart files from the Flutter
engine repo to instead import normal-looking dart files from the
(new) flutter_services package. This package handles exporting the
correct symbols from generated code wherever that may live.
Includes an engine roll to 3551e7a48e2e336777b15c7637af92fd7605b6c5
which contains the new flutter_services package.
Previously, pumpWidget() would do a partial pump (it didn't trigger
Ticker callbacks or post-frame callbacks), and pump() would do a full
pump. This patch brings them closer together. It also makes runApp run a
full actual frame, rather than skipping the transient callback part of
the frame logic. Having "half-frames" in the system was confusing and
could lead to bugs where code expecting to run before the next layout
pass didn't because a "half-frame" ran first.
Also, make Tickers start ticking in the frame that they were started in,
if they were started during a frame. This means we no longer spin a
frame for t=0, we jump straight to the first actual frame.
Other changes in this patch:
* rename WidgetsBinding._runApp to WidgetsBinding.attachRootWidget, so
that tests can use it to more accurately mock out runApp.
* allow loadStructuredData to return synchronously.
* make handleBeginFrame handle not being given a time stamp.
* make DataPipeImageProvider.loadAsync protected (rather than private),
and document it. There wasn't really a reason for it to be private.
* fix ImageConfiguration.toString.
* introduce debugPrintBuildScope and debugPrintScheduleBuildForStacks,
which can help debug problems with widgets getting marked as dirty but
not cleaned.
* make debugPrintRebuildDirtyWidgets say "Building" the first time and
"Rebuilding" the second, to make it clearer when a widget is first
created. This makes debugging widget lifecycle issues much easier.
* make debugDumpApp more resilient.
* debugPrintStack now takes a label that is printed before the stack.
* improve the banner shown for debugPrintBeginFrameBanner.
* various and sundry documentation fixes
This patch includes a number of improvements:
* Material page routes now put a repaint boundary inside their transition so
they don't repaint during the transition.
* Heroes that are on a quest now get a repaint boundary so we repaint them
individually.
* I've hoisted the transparent material for the product items up in the widget
tree, which doesn't affect performance but makes the ink splashes reach the
edge of the product cards.
* I've changed the repaint rainbow visualization to make it easier to see
what's going on.
Previously, we considered them one operation in the compositor, which didn't
trigger caching. Now we have a way to explicitly hint that the compositor
should cache a layer.
Now that protected can be accessed from inside the same library, we can
use protected in a number of new places and we can remove some
trampolines we were using to work around its previous semantics.
The new `empty_statements` lint (in the next DEV roll), flags these empty statements. Harmless, except the one in `basic.dart` that fixes a real-life bug. :)
This introduces the key parts of a paginated data table, not including
the built-in pagination features.
* Provide more data for the data table demo, so there's data to page.
* Introduce a ChangeNotifier class which abstracts out
addListener/removeListener/notifyListeners. We might be able to use
this to simplify existing classes as well, though this patch doesn't
do that.
* Introduce DataTableSource, a delegate for getting data for data
tables. This will also be used by ScrollingDataTable in due course.
* Introduce PaginatedDataTable, a widget that wraps DataTable and only
shows N rows at a time, fed by a DataTableSource.
We used to use this mechanism to paint scrollbars, but it's awkward. The
new approach to scrollbars is much cleaner. This mechanism has no other
clients, so we should remove it.
This makes it possible to substitute 'flutter run' for 'flutter test'
and actually watch a test run on a device.
For any test that depends on flutter_test:
1. Remove any import of 'package:test/test.dart'.
2. Replace `testWidgets('...', (WidgetTester tester) {`
with `testWidgets('...', (WidgetTester tester) async {`
3. Add an "await" in front of calls to any of the following:
* tap()
* tapAt()
* fling()
* flingFrom()
* scroll()
* scrollAt()
* pump()
* pumpWidget()
4. Replace any calls to `tester.flushMicrotasks()` with calls to
`await tester.idle()`.
There's a guarding API that you can use, if you have particularly
complicated tests, to get better error messages. Search for
TestAsyncUtils.
It's safe to remove the unneeded `void`s from setters since the blocking issues in the
`always_declare_return_types` lint have been fixed (https://github.com/dart-lang/linter/). We can also safely flip the bit on `avoid_return_types_on_setters`.
This adds in particular the ability to track the time at which the
framework boots up, and the time at which we are confident we have
completed the first useful frame.
