Both implementations currently use `screen_position_to_index`, which
is inaccurate, and that's why these methods still produce a stub warning.
However, this implementation makes some games work, is a lot better than
a perfect implementation which would require a lot of work and time,
and infinitely better than no implementation at all.
Before this patch, it was possible that some objects did not have a
debug rect despite existing on the stage and interacting with the user.
That was the case for instance for buttons with hit bounds and no up state.
This patch ensures that debug rect is at least as big as highlight bounds,
which are used to highlight focused objects on the stage.
After some past refactors, it's true now that during layout there's
at least one text span, which is ensured by the span normalization.
This refactor simplifies code.
This refactor adds positions to all layout boxes, not only texts.
Positions for bullets and drawings are used only for obtaining
information about their location relative to other layout boxes,
so that searching and other various operations on boxes are easier.
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).
The form loader now loads files using Windows-1252 if the SWF version is
smaller than 6. This roughly matches Flash's behaviour (Flash uses
Windows-1252 on Windows, on macOS a slightly different custom encoding
is used).
Previously, UTF-8 has been (wrongly) used for all SWF files if
System#useCodepage hasn't been set to true, leading to incorrectly
displayed characters.
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's form loader loads text files in the local system codepage if
System#useCodepage has been set to true. Previously, Ruffle always
(wrongly) used UTF-8, leading to incorrectly displayed characters.
This has been fixed. Ruffle now supports loading files with an encoding
other than UTF-8.
As Ruffle doesn't always have access to the system codepage and as it's
not reliably the correct encoding, the crate chardetng has been added.
It's used instead of the system codepage to detect the encoding, and the
data is converted into UTF-8.
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 patch removes `LineData` & `get_line_data` and incorporates
their logic into layout calculation adding `Layout` and `LayoutLine`.
The goal is to simplify operations on the layout, as now
line data is always present and integrated with the layout.
Specialized methods may be added to `Layout` and `LayoutLine`
in the future.
There were two implementations for drawing triangles: one for
Graphics.drawTriangles, and the other for GraphicsTrianglePath.
However, they behave almost identically, so this patch uses
draw_triangles_internal for both.
This patch improves drawing paths in Graphics:
* no error is thrown when there are 0 commands,
* no error is thrown when there are missing data points,
* an error is thrown when the number of coordinates is odd,
* no error is thrown and command processing is stopped
when an unknown command is encountered,
* the vector with parsed commands is removed, as it's not needed.
This menu is shown when the EditText is focused and the mouse hovers over it.
It has the following elements, which may be disabled
when e.g. the field is not editable / selectable:
* Cut,
* Copy,
* Paste,
* Delete,
* Select All.
In AVM1 text fields are somewhat special when handling focus.
When a text field is clicked, it gains focus,
when something else is clicked, it loses the focus.
However, this logic only applies to text fields, other objects
(buttons, movie clips) neither gain focus nor lose it upon press.
This fixes a bug where the code in the first frame of a movie clip
could have been executed after the second frame
(so that instructions like stop did not work properly).
That is because when the first frame was executed in preload
(e.g. for a sprite attached using attachMovie), the actions were queued,
the second frame was executed in run_frame, and then the actions from
the first frame were executed.
Ensuring that all actions are executed after preload fixes this issue.
This shrinks AVM1's Object (from 24 to 16 bytes on x64), and
allows future shrinkage of AVM1's Value (e.g. from 24 to 16 bytes
on x64 after putting all strings behind a Gc pointer).
This patch ensures that the selection in EditText is rendered even when
filters are present (so that cache as bitmap is enabled).
This is done by invalidating the cached bitmap on selection change.
This patch adds multiple properties and controls to EditText tab.
This includes for instance:
* border, border color,
* background, background color,
* editable, selectable, word wrap properties,
* autosize, max chars, restrict, etc.
This patch makes sure that the bitmap is invalidated not only when
a border or background was enabled, but also when both were disabled
and the drawing has only been cleared.
This patch implements proper automatic tab ordering that
behaves exactly the same as in FP.
The automatic order depends only on the position of
the top-left highlight bound corner, referred to as `(x,y)`.
It does not depend on object's size or other corners.
The value of `6y+x` is used to order objects by it.
This means that the next object to be tabbed is the next one
that touches the line `y=-(x-p)/6` (with the smallest `p`).
When two objects have the same value of `6y+x`
(i.e. when the line touches two objects at the same time),
only one of them is included.
This behavior is similar to the naive approach of
"left-to-right, top-to-bottom", but (besides being sometimes
seen as random jumps) takes into account the fact that
the next object to the right may be positioned slightly higher.
This is especially true for objects placed by hand or objects with
different heights (as FP uses the top left corner instead of the center).
This behavior has been discovered experimentally by placing
tabbable objects randomly and bisecting one of their
coordinates to find a difference in behavior.
This lets us view a bitmap directly from the debug ui.
We cache an egui texture handle on the `BitmapData` itself,
and invalidate it whenever the BitmapData gets changed.