You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
76 lines
11 KiB
76 lines
11 KiB
<application>
|
|
<component name="Translation.Cache">
|
|
<option name="lastTrimTime" value="1721278802620" />
|
|
</component>
|
|
<component name="Translation.Settings">
|
|
<option name="primaryLanguage" value="CHINESE" />
|
|
</component>
|
|
<component name="Translation.States">
|
|
<option name="pinTranslationDialog" value="true" />
|
|
<option name="translationDialogHeight" value="702" />
|
|
<option name="translationDialogLocationX" value="591" />
|
|
<option name="translationDialogLocationY" value="536" />
|
|
<option name="translationDialogWidth" value="1253" />
|
|
<histories>
|
|
<item value="evict" />
|
|
<item value="Raw RGBA format. Unencoded bytes, in RGBA row-primary form with premultiplied alpha, 8 bits per channel." />
|
|
<item value="Opaque handle to raw decoded image data (pixels). To obtain an [Image] object, use the [ImageDescriptor] API. To draw an [Image], use one of the methods on the [Canvas] class, such as [Canvas.drawImage]." />
|
|
<item value="Convert an array of pixel values into an [Image] object. The `pixels` parameter is the pixel data. They are packed in bytes in the order described by `format`, then grouped in rows, from left to right, then top to bottom. The `rowBytes` parameter is the number of bytes consumed by each row of pixels in the data buffer. If unspecified, it defaults to `width` multiplied by the number of bytes per pixel in the provided `format`." />
|
|
<item value="Creates an image from a list of bytes. This function attempts to interpret the given bytes an image. If successful, the returned [Future] resolves to the decoded image. Otherwise, the [Future] resolves to null. If the image is animated, this returns the first frame. Consider [instantiateImageCodec] if support for animated images is necessary. This function differs from [ui.decodeImageFromList] in that it defers to [PaintingBinding.instantiateImageCodecWithSize], and therefore can be mocked in tests." />
|
|
<item value="specular" />
|
|
<item value="diffuse" />
|
|
<item value="ambient" />
|
|
<item value="ban_lint_code: don't use this, please use auto fix to resolve this problem" />
|
|
<item value="don't use this" />
|
|
<item value="this" />
|
|
<item value="Write the given [name], possibly with a prefix, assuming that the name can be imported from any of the given [uris]." />
|
|
<item value="Write the code for a declaration of a class with the given [name]. If a list of [interfaces] is provided, then the class will implement those interfaces. If [isAbstract] is `true`, then the class will be abstract. If a [membersWriter] is provided, then it will be invoked to allow members to be generated. If a list of [mixins] is provided, then the class will mix in those classes. If a [nameGroupName] is provided, then the name of the class will be included in the linked edit group with that name. If a [superclass] is given then it will be the superclass of the class. (If a list of [mixins] is provided but no [superclass] is given then the class will extend `Object`.)" />
|
|
<item value="write class declaration" />
|
|
<item value="add constructor declaration" />
|
|
<item value="add combinator" />
|
|
<item value="add block" />
|
|
<item value="add augmentation import directive" />
|
|
<item value="add assert initializer" />
|
|
<item value="add as expression" />
|
|
<item value="add annotation" />
|
|
<item value="add annotated node" />
|
|
<item value="add adjacent strings" />
|
|
<item value="add object pattern" />
|
|
<item value="add constructor initializer" />
|
|
<item value="add cons" />
|
|
<item value="add typed literal" />
|
|
<item value="add type literal" />
|
|
<item value="add type parameter" />
|
|
<item value="add type parameter list" />
|
|
<item value="add uri based directive" />
|
|
<item value="add variable declaration" />
|
|
<item value=""node" exposes metadata about the variable declaration. We could check "node" to show the lint only in some conditions. This line tells custom_lint to render a warning at the location of "node". And the warning shown will use our `code` variable defined above as description." />
|
|
<item value="Whether to exclude these gestures from the semantics tree. For example, the long-press gesture for showing a tooltip is excluded because the tooltip itself is included in the semantics tree directly and so having a gesture to show it would result in duplication of information." />
|
|
<item value="The velocity of the last pointer to be lifted off of the screen." />
|
|
<item value="The velocity the pointer was moving when it stopped contacting the screen. Defaults to zero if not specified in the constructor." />
|
|
<item value="The pointer's velocity when it stopped contacting the screen. Defaults to zero if not specified in the constructor." />
|
|
<item value="A widget that imposes no constraints on its child, allowing it to render at its "natural" size. This allows a child to render at the size it would render if it were alone on an infinite canvas with no constraints. This container will then attempt to adopt the same size, within the limits of its own constraints. If it ends up with a different size, it will align the child based on [alignment]. If the box cannot expand enough to accommodate the entire child, the child will be clipped. In debug mode, if the child overflows the container, a warning will be printed on the console, and black and yellow striped areas will appear where the overflow occurs." />
|
|
<item value="[ConstrainedBox], for a box which imposes constraints on its child. [Align], which loosens the constraints given to the child rather than removing them entirely. [Container], a convenience widget that combines common painting, positioning, and sizing widgets. [OverflowBox], a widget that imposes different constraints on its child than it gets from its parent, possibly allowing the child to overflow the parent. [ConstraintsTransformBox], a widget that sizes its child using a transformed [BoxConstraints], and shows a warning if the child overflows in debug mode." />
|
|
<item value="Creates a widget that imposes no constraints on its child, allowing it to render at its "natural" size. If the child overflows the parents constraints, a warning will be given in debug mode." />
|
|
<item value="Coordinates in Degrees" />
|
|
<item value="See also: [Vertices.new], which creates a set of vertices to draw on the canvas. [Vertices.raw], which creates the vertices using typed data lists rather than unencoded lists. [paint], Image shaders can be used to draw images on a triangular mesh." />
|
|
<item value="The `blendMode` parameter is used to control how the colors in the `vertices` are combined with the colors in the `paint`. If there are no colors specified in `vertices` then the `blendMode` has no effect. If there are colors in the `vertices`, then the color taken from the [Paint.shader] or [Paint.color] in the `paint` is blended with the colors specified in the `vertices` using the `blendMode` parameter. For the purposes of this blending, the colors from the `paint` parameter are considered the source, and the colors from the `vertices` are considered the destination. [BlendMode.dst] ignores the `paint` and uses only the colors of the `vertices`; [BlendMode.src] ignores the colors of the `vertices` and uses only the colors in the `paint`." />
|
|
<item value="Draws a set of [Vertices] onto the canvas as one or more triangles. The [Paint.color] property specifies the default color to use for the triangles. The [Paint.shader] property, if set, overrides the color entirely, replacing it with the colors from the specified [ImageShader], [Gradient], or other shader." />
|
|
<item value="Sends data on the WebSocket connection. The data in [data] must be either a `String`, or a `List<int>` holding bytes." />
|
|
<item value="The standard output stream of the process as a `Stream`. NOTE: `stdin`, `stdout`, and `stderr` are implemented using pipes between the parent process and the spawned subprocess. These pipes have limited capacity. If the subprocess writes to stderr or stdout in excess of that limit without the output being read, the subprocess blocks waiting for the pipe buffer to accept more data. For example: ```dart import 'dart:io'; main() async { var process = await Process.start('cat', ['largefile.txt']); The following await statement will never complete because the subprocess never exits since it is blocked waiting for its stdout to be read. await process.stderr.forEach(print); } ```" />
|
|
<item value="The `colors` parameter, if specified, provides the color for each point in `positions`. Each color is represented as ARGB with 8 bit color channels (like [Color.value]'s internal representation), and the list, if specified, must therefore be half the length of `positions`. Each triangle is painted as a gradient that blends between the three colors at the three points of that triangle. (These colors are then blended with the [Paint] specified in the call to [Canvas.drawVertices].)" />
|
|
<item value="colors" />
|
|
<item value="texture coordinates" />
|
|
<item value="A set of vertex data used by [Canvas.drawVertices]. Vertex data consists of a series of points in the canvas coordinate space. Based on the [VertexMode], these points are interpreted either as independent triangles ([VertexMode.triangles]), as a sliding window of points forming a chain of triangles each sharing one side with the next ([VertexMode.triangleStrip]), or as a fan of triangles with a single shared point ([VertexMode.triangleFan]). Each point can be associated with a color. Each triangle is painted as a gradient that blends between the three colors at the three points of that triangle. If no colors are specified, transparent black is assumed for all the points. These colors are then blended with the [Paint] specified in the call to [Canvas.drawVertices]. This paint is either a solid color ([Paint.color]), or a bitmap, specified using a shader ([Paint.shader]), typically either a gradient ([Gradient]) or image ([ImageFilter]). The bitmap uses the same coordinate space as the canvas (in the case of an [ImageFilter], this is notably different than the coordinate space of the source image; the source image is tiled according to the filter's configuration, and the image that is sampled when painting the triangles is the infinite one after all the repeating is applied.) Each point in the [Vertices] is associated with a specific point on this image. Each triangle is painted by sampling points from this image by interpolating between the three points of the image corresponding to the three points of the triangle. The [Vertices.new] constructor configures all this using lists of [Offset] and [Color] objects. The [Vertices.raw] constructor instead uses [Float32List], [Int32List], and [Uint16List] objects, which more closely corresponds to the data format used internally and therefore reduces some of the conversion overhead. The raw constructor is useful if the data is coming from another source (e.g. a file) and can therefore be parsed directly into the underlying representation." />
|
|
</histories>
|
|
<option name="languageScores">
|
|
<map>
|
|
<entry key="CHINESE" value="561" />
|
|
<entry key="ENGLISH" value="562" />
|
|
<entry key="HAWAIIAN" value="1" />
|
|
<entry key="POLISH" value="1" />
|
|
<entry key="ROMANIAN" value="1" />
|
|
</map>
|
|
</option>
|
|
</component>
|
|
</application> |