Document.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. *
  8. * 1. Redistributions of source code must retain the above copyright notice, this
  9. * list of conditions and the following disclaimer.
  10. *
  11. * 2. Redistributions in binary form must reproduce the above copyright notice,
  12. * this list of conditions and the following disclaimer in the documentation
  13. * and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  19. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  22. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25. */
  26. #include <AK/StringBuilder.h>
  27. #include <LibCore/Timer.h>
  28. #include <LibGUI/Application.h>
  29. #include <LibGUI/DisplayLink.h>
  30. #include <LibGUI/MessageBox.h>
  31. #include <LibJS/Interpreter.h>
  32. #include <LibJS/Parser.h>
  33. #include <LibJS/Runtime/Function.h>
  34. #include <LibJS/Runtime/GlobalObject.h>
  35. #include <LibWeb/Bindings/DocumentWrapper.h>
  36. #include <LibWeb/Bindings/WindowObject.h>
  37. #include <LibWeb/CSS/SelectorEngine.h>
  38. #include <LibWeb/CSS/StyleResolver.h>
  39. #include <LibWeb/DOM/AttributeNames.h>
  40. #include <LibWeb/DOM/Document.h>
  41. #include <LibWeb/DOM/DocumentType.h>
  42. #include <LibWeb/DOM/Element.h>
  43. #include <LibWeb/DOM/ElementFactory.h>
  44. #include <LibWeb/DOM/HTMLBodyElement.h>
  45. #include <LibWeb/DOM/HTMLHeadElement.h>
  46. #include <LibWeb/DOM/HTMLHtmlElement.h>
  47. #include <LibWeb/DOM/HTMLScriptElement.h>
  48. #include <LibWeb/DOM/HTMLTitleElement.h>
  49. #include <LibWeb/DOM/Text.h>
  50. #include <LibWeb/DOM/Window.h>
  51. #include <LibWeb/Dump.h>
  52. #include <LibWeb/Frame/Frame.h>
  53. #include <LibWeb/Layout/LayoutDocument.h>
  54. #include <LibWeb/Layout/LayoutTreeBuilder.h>
  55. #include <LibWeb/Origin.h>
  56. #include <LibWeb/PageView.h>
  57. #include <LibWeb/Parser/CSSParser.h>
  58. #include <stdio.h>
  59. namespace Web {
  60. Document::Document(const URL& url)
  61. : ParentNode(*this, NodeType::DOCUMENT_NODE)
  62. , m_style_resolver(make<StyleResolver>(*this))
  63. , m_style_sheets(CSS::StyleSheetList::create(*this))
  64. , m_url(url)
  65. , m_window(Window::create_with_document(*this))
  66. {
  67. HTML::AttributeNames::initialize();
  68. m_style_update_timer = Core::Timer::create_single_shot(0, [this] {
  69. update_style();
  70. });
  71. }
  72. Document::~Document()
  73. {
  74. }
  75. Origin Document::origin() const
  76. {
  77. if (!m_url.is_valid())
  78. return {};
  79. return { m_url.protocol(), m_url.host(), m_url.port() };
  80. }
  81. void Document::schedule_style_update()
  82. {
  83. if (m_style_update_timer->is_active())
  84. return;
  85. m_style_update_timer->start();
  86. }
  87. bool Document::is_child_allowed(const Node& node) const
  88. {
  89. switch (node.type()) {
  90. case NodeType::DOCUMENT_NODE:
  91. case NodeType::TEXT_NODE:
  92. return false;
  93. case NodeType::COMMENT_NODE:
  94. return true;
  95. case NodeType::DOCUMENT_TYPE_NODE:
  96. return !first_child_of_type<DocumentType>();
  97. case NodeType::ELEMENT_NODE:
  98. return !first_child_of_type<Element>();
  99. default:
  100. return false;
  101. }
  102. }
  103. void Document::fixup()
  104. {
  105. if (!first_child() || !is<DocumentType>(*first_child()))
  106. prepend_child(adopt(*new DocumentType(*this)));
  107. if (is<HTMLHtmlElement>(first_child()->next_sibling()))
  108. return;
  109. auto body = create_element("body");
  110. auto html = create_element("html");
  111. html->append_child(body);
  112. this->donate_all_children_to(body);
  113. this->append_child(html);
  114. }
  115. const HTMLHtmlElement* Document::document_element() const
  116. {
  117. return first_child_of_type<HTMLHtmlElement>();
  118. }
  119. const HTMLHeadElement* Document::head() const
  120. {
  121. auto* html = document_element();
  122. if (!html)
  123. return nullptr;
  124. return html->first_child_of_type<HTMLHeadElement>();
  125. }
  126. const HTMLBodyElement* Document::body() const
  127. {
  128. auto* html = document_element();
  129. if (!html)
  130. return nullptr;
  131. return html->first_child_of_type<HTMLBodyElement>();
  132. }
  133. String Document::title() const
  134. {
  135. auto* head_element = head();
  136. if (!head_element)
  137. return {};
  138. auto* title_element = head_element->first_child_of_type<HTMLTitleElement>();
  139. if (!title_element)
  140. return {};
  141. return title_element->text_content();
  142. }
  143. void Document::attach_to_frame(Badge<Frame>, Frame& frame)
  144. {
  145. m_frame = frame.make_weak_ptr();
  146. for_each_in_subtree([&](auto& node) {
  147. node.document_did_attach_to_frame(frame);
  148. return IterationDecision::Continue;
  149. });
  150. layout();
  151. }
  152. void Document::detach_from_frame(Badge<Frame>, Frame& frame)
  153. {
  154. for_each_in_subtree([&](auto& node) {
  155. node.document_will_detach_from_frame(frame);
  156. return IterationDecision::Continue;
  157. });
  158. m_layout_root = nullptr;
  159. m_frame = nullptr;
  160. }
  161. Color Document::background_color(const Palette& palette) const
  162. {
  163. auto default_color = palette.base();
  164. auto* body_element = body();
  165. if (!body_element)
  166. return default_color;
  167. auto* body_layout_node = body_element->layout_node();
  168. if (!body_layout_node)
  169. return default_color;
  170. auto background_color = body_layout_node->style().property(CSS::PropertyID::BackgroundColor);
  171. if (!background_color.has_value() || !background_color.value()->is_color())
  172. return default_color;
  173. return background_color.value()->to_color(*this);
  174. }
  175. RefPtr<Gfx::Bitmap> Document::background_image() const
  176. {
  177. auto* body_element = body();
  178. if (!body_element)
  179. return {};
  180. auto* body_layout_node = body_element->layout_node();
  181. if (!body_layout_node)
  182. return {};
  183. auto background_image = body_layout_node->style().property(CSS::PropertyID::BackgroundImage);
  184. if (!background_image.has_value() || !background_image.value()->is_image())
  185. return {};
  186. auto& image_value = static_cast<const ImageStyleValue&>(*background_image.value());
  187. if (!image_value.bitmap())
  188. return {};
  189. return *image_value.bitmap();
  190. }
  191. URL Document::complete_url(const String& string) const
  192. {
  193. return m_url.complete_url(string);
  194. }
  195. void Document::invalidate_layout()
  196. {
  197. m_layout_root = nullptr;
  198. }
  199. void Document::force_layout()
  200. {
  201. invalidate_layout();
  202. layout();
  203. }
  204. void Document::layout()
  205. {
  206. if (!frame())
  207. return;
  208. if (!m_layout_root) {
  209. LayoutTreeBuilder tree_builder;
  210. m_layout_root = static_ptr_cast<LayoutDocument>(tree_builder.build(*this));
  211. }
  212. m_layout_root->layout();
  213. m_layout_root->set_needs_display();
  214. }
  215. void Document::update_style()
  216. {
  217. for_each_in_subtree_of_type<Element>([&](auto& element) {
  218. if (element.needs_style_update())
  219. element.recompute_style();
  220. return IterationDecision::Continue;
  221. });
  222. update_layout();
  223. }
  224. void Document::update_layout()
  225. {
  226. if (!frame())
  227. return;
  228. layout();
  229. }
  230. RefPtr<LayoutNode> Document::create_layout_node(const StyleProperties*) const
  231. {
  232. return adopt(*new LayoutDocument(*this, StyleProperties::create()));
  233. }
  234. void Document::set_link_color(Color color)
  235. {
  236. m_link_color = color;
  237. }
  238. void Document::set_active_link_color(Color color)
  239. {
  240. m_active_link_color = color;
  241. }
  242. void Document::set_visited_link_color(Color color)
  243. {
  244. m_visited_link_color = color;
  245. }
  246. const LayoutDocument* Document::layout_node() const
  247. {
  248. return static_cast<const LayoutDocument*>(Node::layout_node());
  249. }
  250. LayoutDocument* Document::layout_node()
  251. {
  252. return static_cast<LayoutDocument*>(Node::layout_node());
  253. }
  254. void Document::set_inspected_node(Node* node)
  255. {
  256. if (m_inspected_node == node)
  257. return;
  258. if (m_inspected_node && m_inspected_node->layout_node())
  259. m_inspected_node->layout_node()->set_needs_display();
  260. m_inspected_node = node;
  261. if (m_inspected_node && m_inspected_node->layout_node())
  262. m_inspected_node->layout_node()->set_needs_display();
  263. }
  264. void Document::set_hovered_node(Node* node)
  265. {
  266. if (m_hovered_node == node)
  267. return;
  268. RefPtr<Node> old_hovered_node = move(m_hovered_node);
  269. m_hovered_node = node;
  270. invalidate_style();
  271. }
  272. Vector<const Element*> Document::get_elements_by_name(const String& name) const
  273. {
  274. Vector<const Element*> elements;
  275. for_each_in_subtree_of_type<Element>([&](auto& element) {
  276. if (element.attribute(HTML::AttributeNames::name) == name)
  277. elements.append(&element);
  278. return IterationDecision::Continue;
  279. });
  280. return elements;
  281. }
  282. RefPtr<Element> Document::query_selector(const StringView& selector_text)
  283. {
  284. auto selector = parse_selector(selector_text);
  285. if (!selector.has_value())
  286. return {};
  287. dump_selector(selector.value());
  288. RefPtr<Element> result;
  289. for_each_in_subtree_of_type<Element>([&](auto& element) {
  290. if (SelectorEngine::matches(selector.value(), element)) {
  291. result = element;
  292. return IterationDecision::Break;
  293. }
  294. return IterationDecision::Continue;
  295. });
  296. return result;
  297. }
  298. NonnullRefPtrVector<Element> Document::query_selector_all(const StringView& selector_text)
  299. {
  300. auto selector = parse_selector(selector_text);
  301. if (!selector.has_value())
  302. return {};
  303. dump_selector(selector.value());
  304. NonnullRefPtrVector<Element> elements;
  305. for_each_in_subtree_of_type<Element>([&](auto& element) {
  306. if (SelectorEngine::matches(selector.value(), element)) {
  307. elements.append(element);
  308. }
  309. return IterationDecision::Continue;
  310. });
  311. return elements;
  312. }
  313. Color Document::link_color() const
  314. {
  315. if (m_link_color.has_value())
  316. return m_link_color.value();
  317. if (!frame())
  318. return Color::Blue;
  319. return frame()->page_view()->palette().link();
  320. }
  321. Color Document::active_link_color() const
  322. {
  323. if (m_active_link_color.has_value())
  324. return m_active_link_color.value();
  325. if (!frame())
  326. return Color::Red;
  327. return frame()->page_view()->palette().active_link();
  328. }
  329. Color Document::visited_link_color() const
  330. {
  331. if (m_visited_link_color.has_value())
  332. return m_visited_link_color.value();
  333. if (!frame())
  334. return Color::Magenta;
  335. return frame()->page_view()->palette().visited_link();
  336. }
  337. JS::Interpreter& Document::interpreter()
  338. {
  339. if (!m_interpreter)
  340. m_interpreter = JS::Interpreter::create<Bindings::WindowObject>(*m_window);
  341. return *m_interpreter;
  342. }
  343. JS::Value Document::run_javascript(const StringView& source)
  344. {
  345. auto parser = JS::Parser(JS::Lexer(source));
  346. auto program = parser.parse_program();
  347. if (parser.has_errors()) {
  348. parser.print_errors();
  349. return JS::js_undefined();
  350. }
  351. dbg() << "Document::run_javascript('" << source << "') will run:";
  352. program->dump(0);
  353. return document().interpreter().run(*program);
  354. }
  355. NonnullRefPtr<Element> Document::create_element(const String& tag_name)
  356. {
  357. return Web::create_element(*this, tag_name);
  358. }
  359. NonnullRefPtr<Text> Document::create_text_node(const String& data)
  360. {
  361. return adopt(*new Text(*this, data));
  362. }
  363. void Document::set_pending_parsing_blocking_script(Badge<HTMLScriptElement>, HTMLScriptElement* script)
  364. {
  365. m_pending_parsing_blocking_script = script;
  366. }
  367. NonnullRefPtr<HTMLScriptElement> Document::take_pending_parsing_blocking_script(Badge<HTMLDocumentParser>)
  368. {
  369. return m_pending_parsing_blocking_script.release_nonnull();
  370. }
  371. void Document::add_script_to_execute_when_parsing_has_finished(Badge<HTMLScriptElement>, HTMLScriptElement& script)
  372. {
  373. m_scripts_to_execute_when_parsing_has_finished.append(script);
  374. }
  375. NonnullRefPtrVector<HTMLScriptElement> Document::take_scripts_to_execute_when_parsing_has_finished(Badge<HTMLDocumentParser>)
  376. {
  377. return move(m_scripts_to_execute_when_parsing_has_finished);
  378. }
  379. void Document::add_script_to_execute_as_soon_as_possible(Badge<HTMLScriptElement>, HTMLScriptElement& script)
  380. {
  381. m_scripts_to_execute_as_soon_as_possible.append(script);
  382. }
  383. NonnullRefPtrVector<HTMLScriptElement> Document::take_scripts_to_execute_as_soon_as_possible(Badge<HTMLDocumentParser>)
  384. {
  385. return move(m_scripts_to_execute_as_soon_as_possible);
  386. }
  387. }