This test verifies the behavior of selecting text using mouse.
It takes into account normal, word, and line selection.
Example use cases covered by this test:
1. selecting characters,
2. selecting words by double-clicking,
3. selecting multiple words by double-clicking and dragging,
4. selecting lines by triple-clicking,
5. selecting multiple lines by triple-clicking and dragging,
6. double-clicking at word boundaries,
7. double-clicking between spaces,
8. changing the underlying text while clicking and dragging,
9. trying to select while the text field is not selectable.
Flash Player *traces* any errors that occur during setting properties
on the newly-constructed object durting AMf deserialization, and
continues deserializing.
This patch makes the caret be drawn using lines.
This ensures that the width of the caret is always 1px.
Additionally, it improves caret positioning, so that it's closer to FP.
This patch removes the drawing used for rendering the border and
the background and renders them using primitives instead.
It provides two methods for drawing the border and the background:
* draw_device_text_box -- when device fonts are used,
* draw_text_box -- when fonts are embedded.
Updated expected images in tests as they are closer to FP now:
* text/auto_size/height,
* text/auto_size/return,
* text/auto_size/width,
* visual/shumway_acid_tests/acid_color_0.
For the test avm2/stage3d_texture it's hard to say whether the current
output is closer to FP or not, as FP renders it with a different scale.
However, I have confirmed that there exists a scale at which FP renders
the text fields exactly as Ruffle after this patch.
The output.txt of this test was invalid,
because it skipped a carriage return after one of the lines.
This has of course something to do with the whole CR/LF/CRLF newline
madness, as the trailing CR formed a CRLF with the "real" newline
character LF, and (I suspect) git replaced it with LF ignoring
CR completely, which badly influenced the current implementation.
This test will be replaced with a proper test when
the implementation is fixed.
Parsing and loading the definitions from an DoAbc/DoAbc2 tag
is visible to ActionScript - any definitions will become accessible,
and the script initializer will be run when accessing any of those
definitions.
We now delay the actual parsing/loading traits from DoAbc2 tags.
This is run before we process any SymbolClass tags, and only runs
the first time that we execute a frame.
This also fixes an issue where we would incorrectly produce a
`VerifyError` during preloading when trying to load a superclass
for a `Class` for a tag in a future frame. That frame might require
other class definitions to be populated first (e.g. by a `Loader`
in the first frame).
Several form loader encoding tests have been added. They test whether
the form loader uses the correct encoding to decode text files with
different SWF versions and settings.
One test has been marked as known failure as it tests how Flash decodes
invalid UTF-8 characters (when decoding as UTF-8), which is not yet
implemented in Ruffle.
If System#useCodepage has been set to true, the form loader now uses the
encoding specified in the HTTP response content type field, if existing,
to decode remote text files. chardetng is now (only) used if the HTTP
response doesn't specify any encoding or if the file is local.
Flash Player handles SymbolClass tags and eager (non-lazy) DoAbc2 tags in an unusual way:
During the first time that a given frame is executed:
1. All SymbolClass tags are processed in order, triggering ClassObject loading (and the associated
script initializer execution, if it hasn't already been run)
2. All eager (non-lazy) DoAbc/DoAbc2 tags have their *final* script initializer executed.
To implement this, we now cache the needed `Script` and symbol class
data during preloading. The first time we execute a frame, we run
the symbolclass class lookup and assignment, followed by the final
script initializer for each DoAbc2 tag in the frame.
This fixes 'minidash' (and probably other crossbridge games as well).
This test verifies how the blur scales when the screen is scaled.
The test includes all known filters which have a blur,
but some of them (gradient filters) are disabled (made invisible)
because they are not yet fully implemented in Ruffle.
They can be made visible when they are functional
so that this test also covers them.
The blur of 1.0 is invariant, so that it should be preserved when scaling.
Using `blur * scale` also scales the invariant, which is wrong.
Tests show that `(blur - 1) * scale + 1` matches FP's behavior.