mirror of
https://github.com/flutter/flutter
synced 2024-09-20 08:42:11 +00:00
387f885481
* add trailing commas on list/map/parameters * add trailing commas on Invocation with nb of arg>1 * add commas for widget containing widgets * add trailing commas if instantiation contains trailing comma * revert bad change
116 lines
4.9 KiB
Dart
116 lines
4.9 KiB
Dart
// Copyright 2015 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
// This example shows how to put some pixels on the screen using the raw
|
|
// interface to the engine.
|
|
|
|
import 'dart:typed_data';
|
|
import 'dart:ui' as ui;
|
|
|
|
ui.Color color;
|
|
|
|
ui.Picture paint(ui.Rect paintBounds) {
|
|
// First we create a PictureRecorder to record the commands we're going to
|
|
// feed in the canvas. The PictureRecorder will eventually produce a Picture,
|
|
// which is an immutable record of those commands.
|
|
final ui.PictureRecorder recorder = ui.PictureRecorder();
|
|
|
|
// Next, we create a canvas from the recorder. The canvas is an interface
|
|
// which can receive drawing commands. The canvas interface is modeled after
|
|
// the SkCanvas interface from Skia. The paintBounds establishes a "cull rect"
|
|
// for the canvas, which lets the implementation discard any commands that
|
|
// are entirely outside this rectangle.
|
|
final ui.Canvas canvas = ui.Canvas(recorder, paintBounds);
|
|
|
|
// The commands draw a circle in the center of the screen.
|
|
final ui.Size size = paintBounds.size;
|
|
canvas.drawCircle(
|
|
size.center(ui.Offset.zero),
|
|
size.shortestSide * 0.45,
|
|
ui.Paint()..color = color,
|
|
);
|
|
|
|
// When we're done issuing painting commands, we end the recording an receive
|
|
// a Picture, which is an immutable record of the commands we've issued. You
|
|
// can draw a Picture into another canvas or include it as part of a
|
|
// composited scene.
|
|
return recorder.endRecording();
|
|
}
|
|
|
|
ui.Scene composite(ui.Picture picture, ui.Rect paintBounds) {
|
|
// The device pixel ratio gives an approximate ratio of the size of pixels on
|
|
// the device's screen to "normal" sized pixels. We commonly work in logical
|
|
// pixels, which are then scalled by the device pixel ratio before being drawn
|
|
// on the screen.
|
|
final double devicePixelRatio = ui.window.devicePixelRatio;
|
|
|
|
// This transform scales the x and y coordinates by the devicePixelRatio.
|
|
final Float64List deviceTransform = Float64List(16)
|
|
..[0] = devicePixelRatio
|
|
..[5] = devicePixelRatio
|
|
..[10] = 1.0
|
|
..[15] = 1.0;
|
|
|
|
// We build a very simple scene graph with two nodes. The root node is a
|
|
// transform that scale its children by the device pixel ratio. This transform
|
|
// lets us paint in "logical" pixels which are converted to device pixels by
|
|
// this scaling operation.
|
|
final ui.SceneBuilder sceneBuilder = ui.SceneBuilder()
|
|
..pushTransform(deviceTransform)
|
|
..addPicture(ui.Offset.zero, picture)
|
|
..pop();
|
|
|
|
// When we're done recording the scene, we call build() to obtain an immutable
|
|
// record of the scene we've recorded.
|
|
return sceneBuilder.build();
|
|
}
|
|
|
|
void beginFrame(Duration timeStamp) {
|
|
final ui.Rect paintBounds = ui.Offset.zero & (ui.window.physicalSize / ui.window.devicePixelRatio);
|
|
// First, record a picture with our painting commands.
|
|
final ui.Picture picture = paint(paintBounds);
|
|
// Second, include that picture in a scene graph.
|
|
final ui.Scene scene = composite(picture, paintBounds);
|
|
// Third, instruct the engine to render that scene graph.
|
|
ui.window.render(scene);
|
|
}
|
|
|
|
void handlePointerDataPacket(ui.PointerDataPacket packet) {
|
|
// The pointer packet contains a number of pointer movements, which we iterate
|
|
// through and process.
|
|
for (ui.PointerData datum in packet.data) {
|
|
if (datum.change == ui.PointerChange.down) {
|
|
// If the pointer went down, we change the color of the circle to blue.
|
|
color = const ui.Color(0xFF0000FF);
|
|
// Rather than calling paint() synchronously, we ask the engine to
|
|
// schedule a frame. The engine will call onBeginFrame when it is actually
|
|
// time to produce the frame.
|
|
ui.window.scheduleFrame();
|
|
} else if (datum.change == ui.PointerChange.up) {
|
|
// Similarly, if the pointer went up, we change the color of the circle to
|
|
// green and schedule a frame. It's harmless to call scheduleFrame many
|
|
// times because the engine will ignore redundant requests up until the
|
|
// point where the engine calls onBeginFrame, which signals the boundary
|
|
// between one frame and another.
|
|
color = const ui.Color(0xFF00FF00);
|
|
ui.window.scheduleFrame();
|
|
}
|
|
}
|
|
}
|
|
|
|
// This function is the primary entry point to your application. The engine
|
|
// calls main() as soon as it has loaded your code.
|
|
void main() {
|
|
color = const ui.Color(0xFF00FF00);
|
|
// The engine calls onBeginFrame whenever it wants us to produce a frame.
|
|
ui.window.onBeginFrame = beginFrame;
|
|
// The engine calls onPointerDataPacket whenever it had updated information
|
|
// about the pointers directed at our app.
|
|
ui.window.onPointerDataPacket = handlePointerDataPacket;
|
|
// Here we kick off the whole process by asking the engine to schedule a new
|
|
// frame. The engine will eventually call onBeginFrame when it is time for us
|
|
// to actually produce the frame.
|
|
ui.window.scheduleFrame();
|
|
}
|