RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 00:27:45 +00:00
Code Issues Activity Actions

LibWeb: Refactor SVG files into their own directory; follow spec layout

Browse source
This commit is contained in:
Matthew Olsson 2020-07-23 09:44:42 -07:00 • committed by Andreas Kling
parent 2e73082203
commit b1299f972c
17 changed files with 386 additions and 172 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Libraries/LibWeb/DOM/Document.cpp
View file

@ -56,6 +56,7 @@
#include <LibWeb/Origin.h>
#include <LibWeb/PageView.h>
#include <LibWeb/Parser/CSSParser.h>
#include <LibWeb/SVG/TagNames.h>
#include <stdio.h>
namespace Web {
@ -69,6 +70,7 @@ Document::Document(const URL& url)
{
HTML::AttributeNames::initialize();
HTML::TagNames::initialize();
SVG::TagNames::initialize();
m_style_update_timer = Core::Timer::create_single_shot(0, [this] {
update_style();

13
Libraries/LibWeb/DOM/ElementFactory.cpp
View file

@ -41,14 +41,15 @@
#include <LibWeb/DOM/HTMLInputElement.h>
#include <LibWeb/DOM/HTMLLinkElement.h>
#include <LibWeb/DOM/HTMLObjectElement.h>
#include <LibWeb/DOM/HTMLPathElement.h>
#include <LibWeb/DOM/HTMLScriptElement.h>
#include <LibWeb/DOM/HTMLStyleElement.h>
#include <LibWeb/DOM/HTMLSvgElement.h>
#include <LibWeb/DOM/HTMLTableCellElement.h>
#include <LibWeb/DOM/HTMLTableElement.h>
#include <LibWeb/DOM/HTMLTableRowElement.h>
#include <LibWeb/DOM/HTMLTitleElement.h>
#include <LibWeb/SVG/SVGPathElement.h>
#include <LibWeb/SVG/SVGSVGElement.h>
#include <LibWeb/SVG/TagNames.h>
namespace Web {
@ -99,10 +100,10 @@ NonnullRefPtr<Element> create_element(Document& document, const FlyString& tag_n
return adopt(*new HTMLCanvasElement(document, lowercase_tag_name));
if (lowercase_tag_name == HTML::TagNames::object)
return adopt(*new HTMLObjectElement(document, lowercase_tag_name));
if (lowercase_tag_name == HTML::TagNames::svg)
return adopt(*new HTMLSvgElement(document, lowercase_tag_name));
if (lowercase_tag_name == HTML::TagNames::path)
return adopt(*new HTMLPathElement(document, lowercase_tag_name));
if (lowercase_tag_name == SVG::TagNames::svg)
return adopt(*new SVG::SVGSVGElement(document, lowercase_tag_name));
if (lowercase_tag_name == SVG::TagNames::path)
return adopt(*new SVG::SVGPathElement(document, lowercase_tag_name));
return adopt(*new Element(document, lowercase_tag_name));
}

603
Libraries/LibWeb/DOM/HTMLPathElement.cpp
View file

@ -1,603 +0,0 @@
/*
* Copyright (c) 2020, Matthew Olsson <matthewcolsson@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <AK/StringBuilder.h>
#include <LibGfx/Path.h>
#include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/Event.h>
#include <LibWeb/DOM/HTMLPathElement.h>
#include <ctype.h>
//#define PATH_DEBUG
namespace Web {
PathDataParser::PathDataParser(const String& source)
: m_source(source)
{
}
Vector<PathInstruction> PathDataParser::parse()
{
parse_whitespace();
while (!done())
parse_drawto();
if (!m_instructions.is_empty() && m_instructions[0].type != PathInstructionType::Move)
ASSERT_NOT_REACHED();
return m_instructions;
}
void PathDataParser::parse_drawto() {
if (match('M') || match('m')) {
parse_moveto();
} else if (match('Z') || match('z')) {
parse_closepath();
} else if (match('L') || match('l')) {
parse_lineto();
} else if (match('H') || match('h')) {
parse_horizontal_lineto();
} else if (match('V') || match('v')) {
parse_vertical_lineto();
} else if (match('C') || match('c')) {
parse_curveto();
} else if (match('S') || match('s')) {
parse_smooth_curveto();
} else if (match('Q') || match('q')) {
parse_quadratic_bezier_curveto();
} else if (match('T') || match('t')) {
parse_smooth_quadratic_bezier_curveto();
} else if (match('A') || match('a')) {
parse_elliptical_arc();
}
}
void PathDataParser::parse_moveto()
{
bool absolute = consume() == 'M';
parse_whitespace();
for (auto& pair : parse_coordinate_pair_sequence())
m_instructions.append({ PathInstructionType::Move, absolute, pair });
}
void PathDataParser::parse_closepath()
{
bool absolute = consume() == 'Z';
m_instructions.append({ PathInstructionType::ClosePath, absolute, {} });
}
void PathDataParser::parse_lineto()
{
bool absolute = consume() == 'L';
parse_whitespace();
for (auto& pair : parse_coordinate_pair_sequence())
m_instructions.append({ PathInstructionType::Line, absolute, pair });
}
void PathDataParser::parse_horizontal_lineto()
{
bool absolute = consume() == 'H';
parse_whitespace();
m_instructions.append({ PathInstructionType::HorizontalLine, absolute, parse_coordinate_sequence() });
}
void PathDataParser::parse_vertical_lineto()
{
bool absolute = consume() == 'V';
parse_whitespace();
m_instructions.append({ PathInstructionType::VerticalLine, absolute, parse_coordinate_sequence() });
}
void PathDataParser::parse_curveto()
{
bool absolute = consume() == 'C';
parse_whitespace();
while (true) {
m_instructions.append({ PathInstructionType::Curve, absolute, parse_coordinate_pair_triplet() });
parse_whitespace();
if (!match_number())
break;
}
}
void PathDataParser::parse_smooth_curveto()
{
bool absolute = consume() == 'S';
parse_whitespace();
while (true) {
m_instructions.append({ PathInstructionType::SmoothCurve, absolute, parse_coordinate_pair_double() });
parse_whitespace();
if (!match_number())
break;
}
}
void PathDataParser::parse_quadratic_bezier_curveto()
{
bool absolute = consume() == 'Q';
parse_whitespace();
while (true) {
m_instructions.append({ PathInstructionType::QuadraticBezierCurve, absolute, parse_coordinate_pair_double() });
parse_whitespace();
if (!match_number())
break;
}
}
void PathDataParser::parse_smooth_quadratic_bezier_curveto()
{
bool absolute = consume() == 'T';
parse_whitespace();
while (true) {
m_instructions.append({ PathInstructionType::SmoothQuadraticBezierCurve, absolute, parse_coordinate_pair_double() });
parse_whitespace();
if (!match_number())
break;
}
}
void PathDataParser::parse_elliptical_arc()
{
bool absolute = consume() == 'A';
parse_whitespace();
while (true) {
m_instructions.append({ PathInstructionType::EllipticalArc, absolute, parse_elliptical_arg_argument() });
parse_whitespace();
if (!match_number())
break;
}
}
float PathDataParser::parse_coordinate()
{
return parse_number();
}
Vector<float> PathDataParser::parse_coordinate_pair()
{
Vector<float> coordinates;
coordinates.append(parse_coordinate());
if (match_comma_whitespace())
parse_comma_whitespace();
coordinates.append(parse_coordinate());
return coordinates;
}
Vector<float> PathDataParser::parse_coordinate_sequence()
{
Vector<float> sequence;
while (true) {
sequence.append(parse_coordinate());
if (match_comma_whitespace())
parse_comma_whitespace();
if (!match_comma_whitespace() && !match_number())
break;
}
return sequence;
}
Vector<Vector<float>> PathDataParser::parse_coordinate_pair_sequence()
{
Vector<Vector<float>> sequence;
while (true) {
sequence.append(parse_coordinate_pair());
if (match_comma_whitespace())
parse_comma_whitespace();
if (!match_comma_whitespace() && !match_number())
break;
}
return sequence;
}
Vector<float> PathDataParser::parse_coordinate_pair_double()
{
Vector<float> coordinates;
coordinates.append(parse_coordinate_pair());
if (match_comma_whitespace())
parse_comma_whitespace();
coordinates.append(parse_coordinate_pair());
return coordinates;
}
Vector<float> PathDataParser::parse_coordinate_pair_triplet()
{
Vector<float> coordinates;
coordinates.append(parse_coordinate_pair());
if (match_comma_whitespace())
parse_comma_whitespace();
coordinates.append(parse_coordinate_pair());
if (match_comma_whitespace())
parse_comma_whitespace();
coordinates.append(parse_coordinate_pair());
return coordinates;
}
Vector<float> PathDataParser::parse_elliptical_arg_argument()
{
Vector<float> numbers;
numbers.append(parse_number());
if (match_comma_whitespace())
parse_comma_whitespace();
numbers.append(parse_number());
if (match_comma_whitespace())
parse_comma_whitespace();
numbers.append(parse_number());
parse_comma_whitespace();
numbers.append(parse_flag());
if (match_comma_whitespace())
parse_comma_whitespace();
numbers.append(parse_flag());
if (match_comma_whitespace())
parse_comma_whitespace();
numbers.append(parse_coordinate_pair());
return numbers;
}
void PathDataParser::parse_whitespace(bool must_match_once)
{
bool matched = false;
while (!done() && match_whitespace()) {
consume();
matched = true;
}
ASSERT(!must_match_once || matched);
}
void PathDataParser::parse_comma_whitespace()
{
if (match(',')) {
consume();
parse_whitespace();
} else {
parse_whitespace(1);
if (match(','))
consume();
parse_whitespace();
}
}
float PathDataParser::parse_fractional_constant()
{
StringBuilder builder;
bool floating_point = false;
while (!done() && isdigit(ch()))
builder.append(consume());
if (match('.')) {
floating_point = true;
builder.append('.');
consume();
while (!done() && isdigit(ch()))
builder.append(consume());
} else {
ASSERT(builder.length() > 0);
}
if (floating_point)
return strtof(builder.to_string().characters(), nullptr);
return builder.to_string().to_int().value();
}
float PathDataParser::parse_number()
{
bool negative = false;
if (match('-')) {
consume();
negative = true;
} else if (match('+')) {
consume();
}
auto number = parse_fractional_constant();
if (match('e') || match('E'))
TODO();
return negative ? number * -1 : number;
}
float PathDataParser::parse_flag()
{
auto number = parse_number();
ASSERT(number == 0 || number == 1);
return number;
}
bool PathDataParser::match_whitespace() const
{
if (done())
return false;
char c = ch();
return c == 0x9 || c == 0x20 || c == 0xa || c == 0xc || c == 0xd;
}
bool PathDataParser::match_comma_whitespace() const
{
return match_whitespace() || match(',');
}
bool PathDataParser::match_number() const
{
return !done() && (isdigit(ch()) || ch() == '-' || ch() == '+');
}
HTMLPathElement::HTMLPathElement(Document& document, const FlyString& tag_name)
: HTMLElement(document, tag_name)
{
}
#ifdef PATH_DEBUG
static void print_instruction(const PathInstruction& instruction)
{
auto& data = instruction.data;
switch (instruction.type) {
case PathInstructionType::Move:
dbg() << "Move (absolute: " << instruction.absolute << ")";
for (size_t i = 0; i < data.size(); i += 2)
dbg() << " x=" << data[i] << ", y=" << data[i + 1];
break;
case PathInstructionType::ClosePath:
dbg() << "ClosePath (absolute=" << instruction.absolute << ")";
break;
case PathInstructionType::Line:
dbg() << "Line (absolute=" << instruction.absolute << ")";
for (size_t i = 0; i < data.size(); i += 2)
dbg() << " x=" << data[i] << ", y=" << data[i + 1];
break;
case PathInstructionType::HorizontalLine:
dbg() << "HorizontalLine (absolute=" << instruction.absolute << ")";
for (size_t i = 0; i < data.size(); ++i)
dbg() << " x=" << data[i];
break;
case PathInstructionType::VerticalLine:
dbg() << "VerticalLine (absolute=" << instruction.absolute << ")";
for (size_t i = 0; i < data.size(); ++i)
dbg() << " y=" << data[i];
break;
case PathInstructionType::Curve:
dbg() << "Curve (absolute=" << instruction.absolute << ")";
for (size_t i = 0; i < data.size(); i += 6)
dbg() << " (x1=" << data[i] << ", y1=" << data[i + 1] << "), (x2=" << data[i + 2] << ", y2=" << data[i + 3] << "), (x=" << data[i + 4] << ", y=" << data[i + 5] << ")";
break;
case PathInstructionType::SmoothCurve:
dbg() << "SmoothCurve (absolute: " << instruction.absolute << ")";
for (size_t i = 0; i < data.size(); i += 4)
dbg() << " (x2=" << data[i] << ", y2=" << data[i + 1] << "), (x=" << data[i + 2] << ", y=" << data[i + 3] << ")";
break;
case PathInstructionType::QuadraticBezierCurve:
dbg() << "QuadraticBezierCurve (absolute: " << instruction.absolute << ")";
for (size_t i = 0; i < data.size(); i += 4)
dbg() << " (x1=" << data[i] << ", y1=" << data[i + 1] << "), (x=" << data[i + 2] << ", y=" << data[i + 3] << ")";
break;
case PathInstructionType::SmoothQuadraticBezierCurve:
dbg() << "SmoothQuadraticBezierCurve (absolute: " << instruction.absolute << ")";
for (size_t i = 0; i < data.size(); i += 2)
dbg() << " x=" << data[i] << ", y=" << data[i + 1];
break;
case PathInstructionType::EllipticalArc:
dbg() << "EllipticalArc (absolute: " << instruction.absolute << ")";
for (size_t i = 0; i < data.size(); i += 7)
dbg() << " (rx=" << data[i] << ", ry=" << data[i + 1] << ") x-axis-rotation=" << data[i + 2] << ", large-arc-flag=" << data[i + 3] << ", sweep-flag=" << data[i + 4] << ", (x=" << data[i + 5] << ", y=" << data[i + 6] << ")";
break;
case PathInstructionType::Invalid:
dbg() << "Invalid (absolute: " << instruction.absolute << ")";
break;
}
}
#endif
void HTMLPathElement::parse_attribute(const FlyString& name, const String& value)
{
HTMLElement::parse_attribute(name, value);
SvgGraphicElement::parse_attribute(name, value);
if (name == "d")
m_instructions = PathDataParser(value).parse();
}
void HTMLPathElement::paint(const SvgPaintingContext& context, Gfx::Painter& painter)
{
Gfx::Path path;
for (auto& instruction : m_instructions) {
auto& absolute = instruction.absolute;
auto& data = instruction.data;
#ifdef PATH_DEBUG
print_instruction(instruction);
#endif
switch (instruction.type) {
case PathInstructionType::Move: {
Gfx::FloatPoint point = { data[0], data[1] };
if (absolute) {
path.move_to(point);
} else {
ASSERT(!path.segments().is_empty());
path.move_to(point + path.segments().last().point());
}
break;
}
case PathInstructionType::ClosePath:
path.close();
break;
case PathInstructionType::Line: {
Gfx::FloatPoint point = { data[0], data[1] };
if (absolute) {
path.line_to(point);
} else {
ASSERT(!path.segments().is_empty());
path.line_to(point + path.segments().last().point());
}
break;
}
case PathInstructionType::HorizontalLine: {
ASSERT(!path.segments().is_empty());
auto last_point = path.segments().last().point();
if (absolute) {
path.line_to(Gfx::FloatPoint { data[0], last_point.y() });
} else {
path.line_to(Gfx::FloatPoint { data[0] + last_point.x(), last_point.y() });
}
break;
}
case PathInstructionType::VerticalLine: {
ASSERT(!path.segments().is_empty());
auto last_point = path.segments().last().point();
if (absolute) {
path.line_to(Gfx::FloatPoint { last_point.x(), data[0] });
} else {
path.line_to(Gfx::FloatPoint { last_point.x(), data[0] + last_point.y() });
}
break;
}
case PathInstructionType::EllipticalArc: {
double rx = data[0];
double ry = data[1];
double x_axis_rotation = data[2] * M_DEG2RAD;
double large_arc_flag = data[3];
double sweep_flag = data[4];
double x_axis_rotation_c = cos(x_axis_rotation);
double x_axis_rotation_s = sin(x_axis_rotation);
auto& last_point = path.segments().last().point();
Gfx::FloatPoint next_point;
if (absolute) {
next_point = { data[5], data[6] };
} else {
next_point = { data[5] + last_point.x(), data[6] + last_point.y() };
}
// Step 1 of out-of-range radii correction
if (rx == 0.0 || ry == 0.0) {
path.line_to(next_point);
break;
}
// Step 2 of out-of-range radii correction
if (rx < 0)
rx *= -1.0;
if (ry < 0)
ry *= -1.0;
// Find (cx, cy), theta_1, theta_delta
// Step 1: Compute (x1', y1')
auto x_avg = (last_point.x() - next_point.x()) / 2.0f;
auto y_avg = (last_point.y() - next_point.y()) / 2.0f;
auto x1p = x_axis_rotation_c * x_avg + x_axis_rotation_s * y_avg;
auto y1p = -x_axis_rotation_s * x_avg + x_axis_rotation_c * y_avg;
// Step 2: Compute (cx', cy')
double x1p_sq = pow(x1p, 2.0);
double y1p_sq = pow(y1p, 2.0);
double rx_sq = pow(rx, 2.0);
double ry_sq = pow(ry, 2.0);
// Step 3 of out-of-range radii correction
double lambda = x1p_sq / rx_sq + y1p_sq / ry_sq;
double multiplier;
if (lambda > 1.0) {
auto lambda_sqrt = sqrt(lambda);
rx *= lambda_sqrt;
ry *= lambda_sqrt;
multiplier = 0.0;
} else {
double numerator = rx_sq * ry_sq - rx_sq * y1p_sq - ry_sq * x1p_sq;
double denominator = rx_sq * y1p_sq + ry_sq * x1p_sq;
multiplier = sqrt(numerator / denominator);
}
if (large_arc_flag == sweep_flag)
multiplier *= -1.0;
double cxp = multiplier * rx * y1p / ry;
double cyp = multiplier * -ry * x1p / rx;
// Step 3: Compute (cx, cy) from (cx', cy')
x_avg = (last_point.x() + next_point.x()) / 2.0f;
y_avg = (last_point.y() + next_point.y()) / 2.0f;
double cx = x_axis_rotation_c * cxp - x_axis_rotation_s * cyp + x_avg;
double cy = x_axis_rotation_s * cxp + x_axis_rotation_c * cyp + y_avg;
double theta_1 = atan2((y1p - cyp) / ry, (x1p - cxp) / rx);
double theta_2 = atan2((-y1p - cyp) / ry, (-x1p - cxp) / rx);
auto theta_delta = theta_2 - theta_1;
if (sweep_flag == 0 && theta_delta > 0.0f) {
theta_delta -= M_TAU;
} else if (sweep_flag != 0 && theta_delta < 0) {
theta_delta += M_TAU;
}
path.elliptical_arc_to(next_point, { cx, cy }, { rx, ry }, x_axis_rotation, theta_1, theta_delta);
break;
}
case PathInstructionType::QuadraticBezierCurve: {
Gfx::FloatPoint through = { data[0], data[1] };
Gfx::FloatPoint point = { data[2], data[3] };
if (absolute) {
path.quadratic_bezier_curve_to(through, point);
} else {
ASSERT(!path.segments().is_empty());
auto last_point = path.segments().last().point();
path.quadratic_bezier_curve_to(through + last_point, point + last_point);
}
break;
}
case PathInstructionType::Curve:
case PathInstructionType::SmoothCurve:
case PathInstructionType::SmoothQuadraticBezierCurve:
TODO();
case PathInstructionType::Invalid:
ASSERT_NOT_REACHED();
}
}
// We need to fill the path before applying the stroke, however the filled
// path must be closed, whereas the stroke path may not necessary be closed.
// Copy the path and close it for filling, but use the previous path for stroke
auto closed_path = path;
closed_path.close();
// Fills are computed as though all paths are closed (https://svgwg.org/svg2-draft/painting.html#FillProperties)
painter.fill_path(closed_path, fill_color(context), Gfx::Painter::WindingRule::EvenOdd);
painter.stroke_path(path, stroke_color(context), stroke_width(context));
}
}

123
Libraries/LibWeb/DOM/HTMLPathElement.h
View file

@ -1,123 +0,0 @@
/*
* Copyright (c) 2020, Matthew Olsson <matthewcolsson@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <LibGfx/Bitmap.h>
#include <LibWeb/DOM/HTMLElement.h>
#include <LibWeb/DOM/SvgContext.h>
namespace Web {
enum class PathInstructionType {
Move,
ClosePath,
Line,
HorizontalLine,
VerticalLine,
Curve,
SmoothCurve,
QuadraticBezierCurve,
SmoothQuadraticBezierCurve,
EllipticalArc,
Invalid,
};
struct PathInstruction {
PathInstructionType type;
bool absolute;
Vector<float> data;
};
class PathDataParser final {
public:
PathDataParser(const String& source);
~PathDataParser() = default;
Vector<PathInstruction> parse();
private:
void parse_drawto();
void parse_moveto();
void parse_closepath();
void parse_lineto();
void parse_horizontal_lineto();
void parse_vertical_lineto();
void parse_curveto();
void parse_smooth_curveto();
void parse_quadratic_bezier_curveto();
void parse_smooth_quadratic_bezier_curveto();
void parse_elliptical_arc();
float parse_coordinate();
Vector<float> parse_coordinate_pair();
Vector<float> parse_coordinate_sequence();
Vector<Vector<float>> parse_coordinate_pair_sequence();
Vector<float> parse_coordinate_pair_double();
Vector<float> parse_coordinate_pair_triplet();
Vector<float> parse_elliptical_arg_argument();
void parse_whitespace(bool must_match_once = false);
void parse_comma_whitespace();
float parse_fractional_constant();
float parse_number();
float parse_flag();
bool match_whitespace() const;
bool match_comma_whitespace() const;
bool match_number() const;
bool match(char c) const { return !done() && ch() == c; }
bool done() const { return m_cursor >= m_source.length(); }
char ch() const { return m_source[m_cursor]; }
char consume() { return m_source[m_cursor++]; }
String m_source;
size_t m_cursor { 0 };
Vector<PathInstruction> m_instructions;
};
class HTMLPathElement final
: public HTMLElement
, public SvgGraphicElement {
public:
HTMLPathElement(Document&, const FlyString& tag_name);
virtual ~HTMLPathElement() override = default;
virtual void parse_attribute(const FlyString& name, const String& value) override;
virtual void paint(const SvgPaintingContext&, Gfx::Painter& painter) override;
private:
Vector<PathInstruction> m_instructions;
};
template<>
inline bool is<HTMLPathElement>(const Node& node)
{
return is<Element>(node) && to<Element>(node).tag_name() == HTML::TagNames::path;
}
}

151
Libraries/LibWeb/DOM/HTMLSvgElement.cpp
View file

@ -1,151 +0,0 @@
/*
* Copyright (c) 2020, Matthew Olsson <matthewcolsson@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <LibGfx/Path.h>
#include <LibWeb/CSS/StyleResolver.h>
#include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/Event.h>
#include <LibWeb/DOM/HTMLPathElement.h>
#include <LibWeb/DOM/HTMLSvgElement.h>
#include <LibWeb/Layout/LayoutSvg.h>
#include <ctype.h>
namespace Web {
static constexpr auto max_svg_area = 16384 * 16384;
HTMLSvgElement::HTMLSvgElement(Document& document, const FlyString& tag_name)
: HTMLElement(document, tag_name)
{
}
void HTMLSvgElement::parse_attribute(const FlyString& name, const String& value)
{
HTMLElement::parse_attribute(name, value);
if (name == "stroke") {
m_stroke_color = Gfx::Color::from_string(value);
} else if (name == "stroke-width") {
auto result = value.to_int();
if (result.has_value())
m_stroke_width = result.value();
} else if (name == "fill") {
m_fill_color = Gfx::Color::from_string(value);
}
}
RefPtr<LayoutNode> HTMLSvgElement::create_layout_node(const StyleProperties* parent_style)
{
auto style = document().style_resolver().resolve_style(*this, parent_style);
if (style->display() == CSS::Display::None)
return nullptr;
return adopt(*new LayoutSvg(document(), *this, move(style)));
}
static Gfx::IntSize bitmap_size_for_canvas(const HTMLSvgElement& canvas)
{
auto width = canvas.width();
auto height = canvas.height();
Checked<size_t> area = width;
area *= height;
if (area.has_overflow()) {
dbg() << "Refusing to create " << width << "x" << height << " svg (overflow)";
return {};
}
if (area.value() > max_svg_area) {
dbg() << "Refusing to create " << width << "x" << height << " svg (exceeds maximum size)";
return {};
}
return Gfx::IntSize(width, height);
}
bool HTMLSvgElement::create_bitmap()
{
auto size = bitmap_size_for_canvas(*this);
if (size.is_empty()) {
m_bitmap = nullptr;
return false;
}
if (!m_bitmap || m_bitmap->size() != size)
m_bitmap = Gfx::Bitmap::create(Gfx::BitmapFormat::RGBA32, size);
Gfx::Painter painter(*m_bitmap);
paint(painter);
return m_bitmap;
}
SvgPaintingContext HTMLSvgElement::make_context() const
{
SvgPaintingContext context;
if (m_stroke_width.has_value())
context.stroke_width = m_stroke_width.value();
if (m_stroke_color.has_value())
context.stroke_color = m_stroke_color.value();
if (m_fill_color.has_value())
context.fill_color = m_fill_color.value();
return context;
}
unsigned HTMLSvgElement::width() const
{
return attribute(HTML::AttributeNames::width).to_uint().value_or(300);
}
unsigned HTMLSvgElement::height() const
{
return attribute(HTML::AttributeNames::height).to_uint().value_or(150);
}
static bool is_svg_graphic_element(const HTMLElement& element)
{
return is<HTMLPathElement>(element);
}
static SvgGraphicElement& as_svg_graphic_element(HTMLElement& element)
{
if (is<HTMLPathElement>(element))
return to<HTMLPathElement>(element);
ASSERT_NOT_REACHED();
}
void HTMLSvgElement::paint(Gfx::Painter& painter)
{
for_each_child([&](Node& child) {
if (is<HTMLElement>(child)) {
auto& element = to<HTMLElement>(child);
if (is_svg_graphic_element(element)) {
as_svg_graphic_element(element).paint(make_context(), painter);
}
}
});
}
}

66
Libraries/LibWeb/DOM/HTMLSvgElement.h
View file

@ -1,66 +0,0 @@
/*
* Copyright (c) 2020, Matthew Olsson <matthewcolsson@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <LibGfx/Bitmap.h>
#include <LibWeb/DOM/HTMLElement.h>
#include <LibWeb/DOM/SvgContext.h>
namespace Web {
class HTMLSvgElement final : public HTMLElement {
public:
HTMLSvgElement(Document&, const FlyString& tag_name);
virtual ~HTMLSvgElement() override = default;
virtual void parse_attribute(const FlyString& name, const String& value) override;
virtual RefPtr<LayoutNode> create_layout_node(const StyleProperties* parent_style) override;
const RefPtr<Gfx::Bitmap> bitmap() const { return m_bitmap; }
bool create_bitmap();
SvgPaintingContext make_context() const;
unsigned width() const;
unsigned height() const;
private:
void paint(Gfx::Painter&);
RefPtr<Gfx::Bitmap> m_bitmap;
Optional<float> m_stroke_width;
Optional<Color> m_stroke_color;
Optional<Color> m_fill_color;
};
template<>
inline bool is<HTMLSvgElement>(const Node& node)
{
return is<Element>(node) && to<Element>(node).tag_name() == HTML::TagNames::svg;
}
}

60
Libraries/LibWeb/DOM/SvgContext.cpp
View file

@ -1,60 +0,0 @@
/*
* Copyright (c) 2020, Matthew Olsson <matthewcolsson@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <AK/FlyString.h>
#include <LibWeb/DOM/SvgContext.h>
namespace Web {
void SvgGraphicElement::parse_attribute(const FlyString& name, const String& value)
{
if (name == "stroke-width") {
m_stroke_width = strtof(value.characters(), nullptr);
} else if (name == "stroke") {
auto result = Gfx::Color::from_string(value);
m_stroke_color = result.value_or(Gfx::Color::Transparent);
} else if (name == "fill") {
auto result = Gfx::Color::from_string(value);
m_fill_color = result.value_or(Gfx::Color::Transparent);
}
}
Gfx::Color SvgGraphicElement::fill_color(const SvgPaintingContext& context) const
{
return m_fill_color.value_or(context.fill_color);
}
Gfx::Color SvgGraphicElement::stroke_color(const SvgPaintingContext& context) const
{
return m_stroke_color.value_or(context.stroke_color);
}
float SvgGraphicElement::stroke_width(const SvgPaintingContext& context) const
{
return m_stroke_width.value_or(context.stroke_width);
}
}

55
Libraries/LibWeb/DOM/SvgContext.h
View file

@ -1,55 +0,0 @@
/*
* Copyright (c) 2020, Matthew Olsson <matthewcolsson@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <LibGfx/Color.h>
#include <LibGfx/Painter.h>
namespace Web {
struct SvgPaintingContext {
Gfx::Color fill_color { Gfx::Color::Black };
Gfx::Color stroke_color { Gfx::Color::Black };
float stroke_width { 1 };
};
class SvgGraphicElement {
public:
virtual void paint(const SvgPaintingContext&, Gfx::Painter& painter) = 0;
void parse_attribute(const FlyString& name, const String& value);
protected:
Gfx::Color fill_color(const SvgPaintingContext&) const;
Gfx::Color stroke_color(const SvgPaintingContext&) const;
float stroke_width(const SvgPaintingContext&) const;
Optional<Gfx::Color> m_fill_color;
Optional<Gfx::Color> m_stroke_color;
Optional<float> m_stroke_width;
};
}