From 1c7a8342782f9abdb7f0bcead40dc7d030c19835 Mon Sep 17 00:00:00 2001 From: asynts Date: Sun, 6 Dec 2020 22:09:24 +0100 Subject: LibWeb: Expose DOM::Range to JavaScript. --- Libraries/LibWeb/Bindings/RangeConstructor.cpp | 58 +++++++++ Libraries/LibWeb/Bindings/RangeConstructor.h | 47 ++++++++ Libraries/LibWeb/Bindings/RangePrototype.cpp | 161 +++++++++++++++++++++++++ Libraries/LibWeb/Bindings/RangePrototype.h | 53 ++++++++ Libraries/LibWeb/Bindings/RangeWrapper.cpp | 47 ++++++++ Libraries/LibWeb/Bindings/RangeWrapper.h | 48 ++++++++ Libraries/LibWeb/Bindings/WindowObject.cpp | 7 ++ Libraries/LibWeb/Bindings/WindowObject.h | 6 + Libraries/LibWeb/CMakeLists.txt | 3 + Libraries/LibWeb/DOM/Range.cpp | 7 +- Libraries/LibWeb/DOM/Range.h | 19 +-- Libraries/LibWeb/Forward.h | 3 + 12 files changed, 448 insertions(+), 11 deletions(-) create mode 100644 Libraries/LibWeb/Bindings/RangeConstructor.cpp create mode 100644 Libraries/LibWeb/Bindings/RangeConstructor.h create mode 100644 Libraries/LibWeb/Bindings/RangePrototype.cpp create mode 100644 Libraries/LibWeb/Bindings/RangePrototype.h create mode 100644 Libraries/LibWeb/Bindings/RangeWrapper.cpp create mode 100644 Libraries/LibWeb/Bindings/RangeWrapper.h diff --git a/Libraries/LibWeb/Bindings/RangeConstructor.cpp b/Libraries/LibWeb/Bindings/RangeConstructor.cpp new file mode 100644 index 0000000000..72f2bc0c52 --- /dev/null +++ b/Libraries/LibWeb/Bindings/RangeConstructor.cpp @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2020, the SerenityOS developers. + * 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 +#include +#include +#include +#include + +namespace Web::Bindings { + +RangeConstructor::RangeConstructor(JS::GlobalObject& global_object) + : NativeFunction(*global_object.function_prototype()) +{ +} + +void RangeConstructor::initialize(JS::GlobalObject& global_object) +{ + NativeFunction::initialize(global_object); + + define_property("length", JS::Value(0), JS::Attribute::Configurable); +} + +JS::Value RangeConstructor::call() +{ + return construct(*this); +} + +JS::Value RangeConstructor::construct(Function&) +{ + auto& window = static_cast(global_object()); + return heap().allocate(window, window, DOM::Range::create(window.impl())); +} + +} diff --git a/Libraries/LibWeb/Bindings/RangeConstructor.h b/Libraries/LibWeb/Bindings/RangeConstructor.h new file mode 100644 index 0000000000..3189c67bc6 --- /dev/null +++ b/Libraries/LibWeb/Bindings/RangeConstructor.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2020, the SerenityOS developers. + * 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 + +namespace Web::Bindings { + +class RangeConstructor final : public JS::NativeFunction { +public: + explicit RangeConstructor(JS::GlobalObject&); + + void initialize(JS::GlobalObject&) override; + + JS::Value call() override; + JS::Value construct(JS::Function& new_target) override; + +private: + bool has_constructor() const override { return true; } + const char* class_name() const override { return "RangeConstructor"; } +}; + +} diff --git a/Libraries/LibWeb/Bindings/RangePrototype.cpp b/Libraries/LibWeb/Bindings/RangePrototype.cpp new file mode 100644 index 0000000000..6bde99794f --- /dev/null +++ b/Libraries/LibWeb/Bindings/RangePrototype.cpp @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2020, the SerenityOS developers. + * 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 +#include +#include +#include +#include +#include +#include + +namespace Web::Bindings { + +RangePrototype::RangePrototype(JS::GlobalObject& global_object) + : Object(*global_object.object_prototype()) +{ +} + +void RangePrototype::initialize(JS::GlobalObject& global_object) +{ + auto default_attributes = JS::Attribute::Enumerable | JS::Attribute::Configurable; + + Object::initialize(global_object); + + define_native_function("setStart", set_start, 2); + define_native_function("setEnd", set_end, 2); + define_native_function("cloneRange", clone_range, 0); + + define_native_property("startContainer", start_container_getter, nullptr, default_attributes); + define_native_property("endContainer", end_container_getter, nullptr, default_attributes); + define_native_property("startOffset", start_offset_getter, nullptr, default_attributes); + define_native_property("endOffset", end_offset_getter, nullptr, default_attributes); +} + +static DOM::Range* impl_from(JS::VM& vm, JS::GlobalObject& global_object) +{ + auto* this_object = vm.this_value(global_object).to_object(global_object); + if (!this_object) + return nullptr; + if (StringView("RangeWrapper") != this_object->class_name()) { + vm.throw_exception(global_object, JS::ErrorType::NotA, "Range"); + return nullptr; + } + return &static_cast(this_object)->impl(); +} + +JS_DEFINE_NATIVE_FUNCTION(RangePrototype::set_start) +{ + auto* impl = impl_from(vm, global_object); + if (!impl) + return {}; + + auto arg0 = vm.argument(0).to_object(global_object); + if (vm.exception()) + return {}; + auto arg1 = vm.argument(1).to_number(global_object); + if (vm.exception()) + return {}; + + if (!static_cast(arg0)->is_node_wrapper()) { + vm.throw_exception(global_object, JS::ErrorType::NotA, "Range"); + return {}; + } + + impl->set_start(static_cast(arg0)->impl(), arg1.as_i32()); + + return JS::js_undefined(); +} + +JS_DEFINE_NATIVE_FUNCTION(RangePrototype::set_end) +{ + auto* impl = impl_from(vm, global_object); + if (!impl) + return {}; + + auto arg0 = vm.argument(0).to_object(global_object); + if (vm.exception()) + return {}; + auto arg1 = vm.argument(1).to_number(global_object); + if (vm.exception()) + return {}; + + if (!static_cast(arg0)->is_node_wrapper()) { + vm.throw_exception(global_object, JS::ErrorType::NotA, "Range"); + return {}; + } + + impl->set_end(static_cast(arg0)->impl(), arg1.as_i32()); + + return JS::js_undefined(); +} + +JS_DEFINE_NATIVE_FUNCTION(RangePrototype::clone_range) +{ + auto* impl = impl_from(vm, global_object); + if (!impl) + return {}; + + return wrap(global_object, *impl->clone_range()); +} + +JS_DEFINE_NATIVE_GETTER(RangePrototype::start_container_getter) +{ + auto* impl = impl_from(vm, global_object); + if (!impl) + return {}; + + return wrap(global_object, *impl->start_container()); +} + +JS_DEFINE_NATIVE_GETTER(RangePrototype::end_container_getter) +{ + auto* impl = impl_from(vm, global_object); + if (!impl) + return {}; + + return wrap(global_object, *impl->end_container()); +} + +JS_DEFINE_NATIVE_GETTER(RangePrototype::start_offset_getter) +{ + auto* impl = impl_from(vm, global_object); + if (!impl) + return {}; + + return JS::Value(impl->start_offset()); +} + +JS_DEFINE_NATIVE_GETTER(RangePrototype::end_offset_getter) +{ + auto* impl = impl_from(vm, global_object); + if (!impl) + return {}; + + return JS::Value(impl->end_offset()); +} + +} diff --git a/Libraries/LibWeb/Bindings/RangePrototype.h b/Libraries/LibWeb/Bindings/RangePrototype.h new file mode 100644 index 0000000000..560eaa4a7c --- /dev/null +++ b/Libraries/LibWeb/Bindings/RangePrototype.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2020, the SerenityOS developers. + * 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 + +namespace Web::Bindings { + +class RangePrototype final : public JS::Object { + JS_OBJECT(RangePrototype, JS::Object); + +public: + explicit RangePrototype(JS::GlobalObject&); + + void initialize(JS::GlobalObject&) override; + +private: + JS_DECLARE_NATIVE_FUNCTION(set_start); + JS_DECLARE_NATIVE_FUNCTION(set_end); + JS_DECLARE_NATIVE_FUNCTION(clone_range); + + JS_DECLARE_NATIVE_GETTER(start_container_getter); + JS_DECLARE_NATIVE_GETTER(end_container_getter); + JS_DECLARE_NATIVE_GETTER(start_offset_getter); + JS_DECLARE_NATIVE_GETTER(end_offset_getter); + JS_DECLARE_NATIVE_GETTER(collapsed_getter); +}; + +} diff --git a/Libraries/LibWeb/Bindings/RangeWrapper.cpp b/Libraries/LibWeb/Bindings/RangeWrapper.cpp new file mode 100644 index 0000000000..dc58a4358d --- /dev/null +++ b/Libraries/LibWeb/Bindings/RangeWrapper.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2020, the SerenityOS developers. + * 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 +#include +#include +#include +#include + +namespace Web::Bindings { + +RangeWrapper::RangeWrapper(JS::GlobalObject& global_object, DOM::Range& impl) + : Wrapper(global_object) + , m_impl(impl) +{ + set_prototype(static_cast(global_object).range_prototype()); +} + +RangeWrapper* wrap(JS::GlobalObject& global_object, DOM::Range& impl) +{ + return static_cast(wrap_impl(global_object, impl)); +} + +} diff --git a/Libraries/LibWeb/Bindings/RangeWrapper.h b/Libraries/LibWeb/Bindings/RangeWrapper.h new file mode 100644 index 0000000000..5528d81911 --- /dev/null +++ b/Libraries/LibWeb/Bindings/RangeWrapper.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2020, the SerenityOS developers. + * 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 + +namespace Web::Bindings { + +class RangeWrapper final : public Wrapper { +public: + RangeWrapper(JS::GlobalObject&, DOM::Range&); + + DOM::Range& impl() { return m_impl; } + const DOM::Range& impl() const { return m_impl; } + +private: + virtual const char* class_name() const override { return "RangeWrapper"; } + + NonnullRefPtr m_impl; +}; + +RangeWrapper* wrap(JS::GlobalObject&, DOM::Range&); + +} diff --git a/Libraries/LibWeb/Bindings/WindowObject.cpp b/Libraries/LibWeb/Bindings/WindowObject.cpp index 5116b9c308..3722ca56d9 100644 --- a/Libraries/LibWeb/Bindings/WindowObject.cpp +++ b/Libraries/LibWeb/Bindings/WindowObject.cpp @@ -41,6 +41,8 @@ #include #include #include +#include +#include #include #include #include @@ -86,6 +88,11 @@ void WindowObject::initialize() m_xhr_prototype = heap().allocate(*this, *this); add_constructor("XMLHttpRequest", m_xhr_constructor, m_xhr_prototype); + + m_range_prototype = heap().allocate(*this, *this); + m_range_constructor = heap().allocate(*this, *this); + m_range_constructor->define_property("prototype", m_range_prototype); + add_constructor("Range", m_range_constructor, m_range_prototype); } WindowObject::~WindowObject() diff --git a/Libraries/LibWeb/Bindings/WindowObject.h b/Libraries/LibWeb/Bindings/WindowObject.h index b3e1e92959..729363d3b1 100644 --- a/Libraries/LibWeb/Bindings/WindowObject.h +++ b/Libraries/LibWeb/Bindings/WindowObject.h @@ -50,6 +50,9 @@ public: XMLHttpRequestPrototype* xhr_prototype() { return m_xhr_prototype; } XMLHttpRequestConstructor* xhr_constructor() { return m_xhr_constructor; } + RangePrototype* range_prototype() { return m_range_prototype; } + RangeConstructor* range_constructor() { return m_range_constructor; } + private: virtual const char* class_name() const override { return "WindowObject"; } virtual void visit_edges(Visitor&) override; @@ -76,6 +79,9 @@ private: XMLHttpRequestConstructor* m_xhr_constructor { nullptr }; XMLHttpRequestPrototype* m_xhr_prototype { nullptr }; + + RangePrototype* m_range_prototype { nullptr }; + RangeConstructor* m_range_constructor { nullptr }; }; } diff --git a/Libraries/LibWeb/CMakeLists.txt b/Libraries/LibWeb/CMakeLists.txt index 94d7e04a62..9a97a777a4 100644 --- a/Libraries/LibWeb/CMakeLists.txt +++ b/Libraries/LibWeb/CMakeLists.txt @@ -11,6 +11,9 @@ set(SOURCES Bindings/XMLHttpRequestConstructor.cpp Bindings/XMLHttpRequestPrototype.cpp Bindings/XMLHttpRequestWrapper.cpp + Bindings/RangeConstructor.cpp + Bindings/RangePrototype.cpp + Bindings/RangeWrapper.cpp CSS/DefaultStyleSheetSource.cpp CSS/Length.cpp CSS/Parser/CSSParser.cpp diff --git a/Libraries/LibWeb/DOM/Range.cpp b/Libraries/LibWeb/DOM/Range.cpp index 94e8162b5a..377eb7f882 100644 --- a/Libraries/LibWeb/DOM/Range.cpp +++ b/Libraries/LibWeb/DOM/Range.cpp @@ -27,13 +27,14 @@ #include #include #include +#include namespace Web::DOM { -Range::Range(Document& document) - : m_start_container(document) +Range::Range(Window& window) + : m_start_container(window.document()) , m_start_offset(0) - , m_end_container(document) + , m_end_container(window.document()) , m_end_offset(0) { } diff --git a/Libraries/LibWeb/DOM/Range.h b/Libraries/LibWeb/DOM/Range.h index c720af6c8f..608112fb14 100644 --- a/Libraries/LibWeb/DOM/Range.h +++ b/Libraries/LibWeb/DOM/Range.h @@ -28,6 +28,7 @@ #include #include +#include namespace Web::DOM { @@ -35,17 +36,19 @@ class Range final : public RefCounted , public Bindings::Wrappable { public: - // using WrapperType = Bindings::RangeWrapper; + using WrapperType = Bindings::RangeWrapper; - static NonnullRefPtr create(Document& document) + static NonnullRefPtr create(Window& window) { - return adopt(*new Range(document)); + return adopt(*new Range(window)); } static NonnullRefPtr create(Node& start_container, size_t start_offset, Node& end_container, size_t end_offset) { return adopt(*new Range(start_container, start_offset, end_container, end_offset)); } + // FIXME: There are a ton of methods missing here. + Node* start_container() { return m_start_container; } unsigned start_offset() { return m_start_offset; } @@ -57,16 +60,16 @@ public: return start_container() == end_container() && start_offset() == end_offset(); } - void set_start(Node& container, JS::Value& offset) + void set_start(Node& container, unsigned offset) { m_start_container = container; - m_start_offset = (unsigned)offset.as_i32(); + m_start_offset = offset; } - void set_end(Node& container, JS::Value& offset) + void set_end(Node& container, unsigned offset) { m_end_container = container; - m_end_offset = (unsigned)offset.as_i32(); + m_end_offset = offset; } NonnullRefPtr inverted() const; @@ -74,7 +77,7 @@ public: NonnullRefPtr clone_range() const; private: - explicit Range(Document&); + explicit Range(Window&); Range(Node& start_container, size_t start_offset, Node& end_container, size_t end_offset); NonnullRefPtr m_start_container; diff --git a/Libraries/LibWeb/Forward.h b/Libraries/LibWeb/Forward.h index d525f91dfa..06cef0bc2f 100644 --- a/Libraries/LibWeb/Forward.h +++ b/Libraries/LibWeb/Forward.h @@ -288,5 +288,8 @@ class Wrapper; class XMLHttpRequestConstructor; class XMLHttpRequestPrototype; class XMLHttpRequestWrapper; +class RangeConstructor; +class RangePrototype; +class RangeWrapper; } -- cgit v1.2.3