RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-14 08:54:58 +00:00
Code Issues Activity Actions

LibWeb: Move mouse event and label logic from layout to painting tree

Browse source 
Input events have nothing to do with layout, so let's not send them to
layout nodes.

The job of Paintable starts to become clear. It represents a paintable
item that can be rendered into the viewport, which means it can also
be targeted by the mouse cursor.
This commit is contained in:
Andreas Kling 2022-03-10 22:46:35 +01:00
parent ed84fbce47
commit cb0c5390ff
35 changed files with 560 additions and 429 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Userland/Libraries/LibWeb/CMakeLists.txt
View file

@ -246,6 +246,7 @@ set(SOURCES
Layout/InlineLevelIterator.cpp
Layout/InlineNode.cpp
Layout/Label.cpp
Layout/LabelableNode.cpp
Layout/LayoutPosition.cpp
Layout/LineBox.cpp
Layout/LineBoxFragment.cpp
@ -289,6 +290,7 @@ set(SOURCES
Painting/CheckBoxPaintable.cpp
Painting/ImagePaintable.cpp
Painting/InlinePaintable.cpp
Painting/LabelablePaintable.cpp
Painting/MarkerPaintable.cpp
Painting/NestedBrowsingContextPaintable.cpp
Painting/PaintContext.cpp

7
Userland/Libraries/LibWeb/DOM/Node.cpp
View file

@ -1010,6 +1010,13 @@ size_t Node::length() const
return child_count();
}
Painting::Paintable const* Node::paintable() const
{
if (!layout_node())
return nullptr;
return layout_node()->paintable();
}
Painting::PaintableBox const* Node::paint_box() const
{
if (!layout_node())

1
Userland/Libraries/LibWeb/DOM/Node.h
View file

@ -159,6 +159,7 @@ public:
Layout::Node* layout_node() { return m_layout_node; }
Painting::PaintableBox const* paint_box() const;
Painting::Paintable const* paintable() const;
void set_layout_node(Badge<Layout::Node>, Layout::Node*) const;

4
Userland/Libraries/LibWeb/Forward.h
View file

@ -265,9 +265,13 @@ class PerformanceTiming;
namespace Web::Painting {
enum class PaintPhase;
class ButtonPaintable;
class CheckBoxPaintable;
class LabelablePaintable;
class Paintable;
class PaintableBox;
class PaintableWithLines;
class TextPaintable;
}
namespace Web::RequestIdleCallback {

4
Userland/Libraries/LibWeb/HTML/HTMLInputElement.cpp
View file

@ -29,7 +29,7 @@ HTMLInputElement::~HTMLInputElement()
{
}
void HTMLInputElement::did_click_button(Badge<Layout::ButtonBox>)
void HTMLInputElement::did_click_button(Badge<Painting::ButtonPaintable>)
{
// FIXME: This should be a PointerEvent.
dispatch_event(DOM::Event::create(EventNames::click));
@ -42,7 +42,7 @@ void HTMLInputElement::did_click_button(Badge<Layout::ButtonBox>)
}
}
void HTMLInputElement::did_click_checkbox(Badge<Layout::CheckBox>)
void HTMLInputElement::did_click_checkbox(Badge<Painting::CheckBoxPaintable>)
{
// FIXME: This should be a PointerEvent.
auto click_event = DOM::Event::create(EventNames::click);

4
Userland/Libraries/LibWeb/HTML/HTMLInputElement.h
View file

@ -73,8 +73,8 @@ public:
};
void set_checked(bool, ChangeSource = ChangeSource::Programmatic, ShouldRunActivationBehavior = ShouldRunActivationBehavior::Yes);
void did_click_button(Badge<Layout::ButtonBox>);
void did_click_checkbox(Badge<Layout::CheckBox>);
void did_click_button(Badge<Painting::ButtonPaintable>);
void did_click_checkbox(Badge<Painting::CheckBoxPaintable>);
void did_edit_text_node(Badge<BrowsingContext>);

11
Userland/Libraries/LibWeb/Layout/BlockContainer.cpp
View file

@ -69,17 +69,6 @@ void BlockContainer::set_scroll_offset(const Gfx::FloatPoint& offset)
set_needs_display();
}
bool BlockContainer::handle_mousewheel(Badge<EventHandler>, const Gfx::IntPoint&, unsigned int, unsigned int, int wheel_delta_x, int wheel_delta_y)
{
if (!is_scrollable())
return false;
auto new_offset = m_scroll_offset;
new_offset.translate_by(wheel_delta_x, wheel_delta_y);
set_scroll_offset(new_offset);
return true;
}
Painting::PaintableWithLines const* BlockContainer::paint_box() const
{
return static_cast<Painting::PaintableWithLines const*>(Box::paint_box());

2
Userland/Libraries/LibWeb/Layout/BlockContainer.h
View file

@ -35,8 +35,6 @@ public:
private:
virtual bool is_block_container() const final { return true; }
virtual bool wants_mouse_events() const override { return false; }
virtual bool handle_mousewheel(Badge<EventHandler>, const Gfx::IntPoint&, unsigned buttons, unsigned modifiers, int wheel_delta_x, int wheel_delta_y) override;
Gfx::FloatPoint m_scroll_offset;
};

75
Userland/Libraries/LibWeb/Layout/ButtonBox.cpp
View file

@ -31,81 +31,6 @@ void ButtonBox::prepare_for_replaced_layout()
set_intrinsic_height(font().glyph_height());
}
void ButtonBox::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned)
{
if (button != GUI::MouseButton::Primary || !dom_node().enabled())
return;
m_being_pressed = true;
set_needs_display();
m_tracking_mouse = true;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(this);
}
void ButtonBox::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
if (!m_tracking_mouse || button != GUI::MouseButton::Primary || !dom_node().enabled())
return;
// NOTE: Handling the click may run arbitrary JS, which could disappear this node.
NonnullRefPtr protected_this = *this;
NonnullRefPtr protected_browsing_context = browsing_context();
bool is_inside_node_or_label = enclosing_int_rect(paint_box()->absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Label::is_inside_associated_label(*this, position);
if (is_inside_node_or_label)
dom_node().did_click_button({});
m_being_pressed = false;
m_tracking_mouse = false;
protected_browsing_context->event_handler().set_mouse_event_tracking_layout_node(nullptr);
}
void ButtonBox::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned)
{
if (!m_tracking_mouse || !dom_node().enabled())
return;
bool is_inside_node_or_label = enclosing_int_rect(paint_box()->absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Label::is_inside_associated_label(*this, position);
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
void ButtonBox::handle_associated_label_mousedown(Badge<Label>)
{
m_being_pressed = true;
set_needs_display();
}
void ButtonBox::handle_associated_label_mouseup(Badge<Label>)
{
// NOTE: Handling the click may run arbitrary JS, which could disappear this node.
NonnullRefPtr protected_this = *this;
NonnullRefPtr protected_browsing_context = browsing_context();
dom_node().did_click_button({});
m_being_pressed = false;
}
void ButtonBox::handle_associated_label_mousemove(Badge<Label>, bool is_inside_node_or_label)
{
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
RefPtr<Painting::Paintable> ButtonBox::create_paintable() const
{
return Painting::ButtonPaintable::create(*this);

16
Userland/Libraries/LibWeb/Layout/ButtonBox.h
View file

@ -21,22 +21,8 @@ public:
const HTML::HTMLInputElement& dom_node() const { return static_cast<const HTML::HTMLInputElement&>(LabelableNode::dom_node()); }
HTML::HTMLInputElement& dom_node() { return static_cast<HTML::HTMLInputElement&>(LabelableNode::dom_node()); }
bool being_pressed() const { return m_being_pressed; }
virtual RefPtr<Painting::Paintable> create_paintable() const override;
private:
virtual bool wants_mouse_events() const override { return true; }
virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned buttons, unsigned modifiers) override;
virtual void handle_associated_label_mousedown(Badge<Label>) override;
virtual void handle_associated_label_mouseup(Badge<Label>) override;
virtual void handle_associated_label_mousemove(Badge<Label>, bool is_inside_node_or_label) override;
bool m_being_pressed { false };
bool m_tracking_mouse { false };
virtual RefPtr<Painting::Paintable> create_paintable() const override;
};
}

84
Userland/Libraries/LibWeb/Layout/CheckBox.cpp
View file

@ -4,10 +4,7 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibGUI/Event.h>
#include <LibGfx/Font.h>
#include <LibGfx/Painter.h>
#include <LibGfx/StylePainter.h>
#include <LibWeb/HTML/BrowsingContext.h>
#include <LibWeb/HTML/HTMLInputElement.h>
#include <LibWeb/Layout/CheckBox.h>
@ -27,87 +24,6 @@ CheckBox::~CheckBox()
{
}
void CheckBox::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned)
{
if (button != GUI::MouseButton::Primary || !dom_node().enabled())
return;
m_being_pressed = true;
set_needs_display();
m_tracking_mouse = true;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(this);
}
void CheckBox::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
if (!m_tracking_mouse || button != GUI::MouseButton::Primary || !dom_node().enabled())
return;
// NOTE: Changing the checked state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
bool is_inside_node_or_label = enclosing_int_rect(paint_box()->absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Label::is_inside_associated_label(*this, position);
if (is_inside_node_or_label) {
dom_node().did_click_checkbox({});
dom_node().set_checked(!dom_node().checked(), HTML::HTMLInputElement::ChangeSource::User);
}
m_being_pressed = false;
m_tracking_mouse = false;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(nullptr);
}
void CheckBox::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned)
{
if (!m_tracking_mouse || !dom_node().enabled())
return;
bool is_inside_node_or_label = enclosing_int_rect(paint_box()->absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Label::is_inside_associated_label(*this, position);
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
void CheckBox::handle_associated_label_mousedown(Badge<Label>)
{
if (!dom_node().enabled())
return;
m_being_pressed = true;
set_needs_display();
}
void CheckBox::handle_associated_label_mouseup(Badge<Label>)
{
if (!dom_node().enabled())
return;
// NOTE: Changing the checked state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
dom_node().did_click_checkbox({});
dom_node().set_checked(!dom_node().checked(), HTML::HTMLInputElement::ChangeSource::User);
m_being_pressed = false;
}
void CheckBox::handle_associated_label_mousemove(Badge<Label>, bool is_inside_node_or_label)
{
if (m_being_pressed == is_inside_node_or_label || !dom_node().enabled())
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
RefPtr<Painting::Paintable> CheckBox::create_paintable() const
{
return Painting::CheckBoxPaintable::create(*this);

16
Userland/Libraries/LibWeb/Layout/CheckBox.h
View file

@ -19,22 +19,8 @@ public:
const HTML::HTMLInputElement& dom_node() const { return static_cast<const HTML::HTMLInputElement&>(LabelableNode::dom_node()); }
HTML::HTMLInputElement& dom_node() { return static_cast<HTML::HTMLInputElement&>(LabelableNode::dom_node()); }
bool being_pressed() const { return m_being_pressed; }
virtual RefPtr<Painting::Paintable> create_paintable() const override;
private:
virtual bool wants_mouse_events() const override { return true; }
virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned buttons, unsigned modifiers) override;
virtual void handle_associated_label_mousedown(Badge<Label>) override;
virtual void handle_associated_label_mouseup(Badge<Label>) override;
virtual void handle_associated_label_mousemove(Badge<Label>, bool is_inside_node_or_label) override;
bool m_being_pressed { false };
bool m_tracking_mouse { false };
virtual RefPtr<Painting::Paintable> create_paintable() const override;
};
}

24
Userland/Libraries/LibWeb/Layout/Label.cpp
View file

@ -5,16 +5,14 @@
*/
#include <LibGUI/Event.h>
#include <LibGfx/Painter.h>
#include <LibGfx/StylePainter.h>
#include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/Element.h>
#include <LibWeb/HTML/BrowsingContext.h>
#include <LibWeb/Layout/InitialContainingBlock.h>
#include <LibWeb/Layout/Label.h>
#include <LibWeb/Layout/LabelableNode.h>
#include <LibWeb/Layout/TextNode.h>
#include <LibWeb/Painting/Paintable.h>
#include <LibWeb/Painting/LabelablePaintable.h>
namespace Web::Layout {
@ -27,18 +25,18 @@ Label::~Label()
{
}
void Label::handle_mousedown_on_label(Badge<TextNode>, const Gfx::IntPoint&, unsigned button)
void Label::handle_mousedown_on_label(Badge<Painting::TextPaintable>, Gfx::IntPoint const&, unsigned button)
{
if (button != GUI::MouseButton::Primary)
return;
if (auto* control = labeled_control(); control)
control->handle_associated_label_mousedown({});
control->paintable()->handle_associated_label_mousedown({});
m_tracking_mouse = true;
}
void Label::handle_mouseup_on_label(Badge<TextNode>, const Gfx::IntPoint& position, unsigned button)
void Label::handle_mouseup_on_label(Badge<Painting::TextPaintable>, Gfx::IntPoint const& position, unsigned button)
{
if (!m_tracking_mouse || button != GUI::MouseButton::Primary)
return;
@ -51,13 +49,13 @@ void Label::handle_mouseup_on_label(Badge<TextNode>, const Gfx::IntPoint& positi
bool is_inside_label = enclosing_int_rect(paint_box()->absolute_rect()).contains(position);
if (is_inside_control || is_inside_label)
control->handle_associated_label_mouseup({});
control->paintable()->handle_associated_label_mouseup({});
}
m_tracking_mouse = false;
}
void Label::handle_mousemove_on_label(Badge<TextNode>, const Gfx::IntPoint& position, unsigned)
void Label::handle_mousemove_on_label(Badge<Painting::TextPaintable>, Gfx::IntPoint const& position, unsigned)
{
if (!m_tracking_mouse)
return;
@ -66,18 +64,18 @@ void Label::handle_mousemove_on_label(Badge<TextNode>, const Gfx::IntPoint& posi
bool is_inside_control = enclosing_int_rect(control->paint_box()->absolute_rect()).contains(position);
bool is_inside_label = enclosing_int_rect(paint_box()->absolute_rect()).contains(position);
control->handle_associated_label_mousemove({}, is_inside_control || is_inside_label);
control->paintable()->handle_associated_label_mousemove({}, is_inside_control || is_inside_label);
}
}
bool Label::is_inside_associated_label(LabelableNode& control, const Gfx::IntPoint& position)
bool Label::is_inside_associated_label(LabelableNode const& control, const Gfx::IntPoint& position)
{
if (auto* label = label_for_control_node(control); label)
return enclosing_int_rect(label->paint_box()->absolute_rect()).contains(position);
return false;
}
bool Label::is_associated_label_hovered(LabelableNode& control)
bool Label::is_associated_label_hovered(LabelableNode const& control)
{
if (auto* label = label_for_control_node(control); label) {
if (label->document().hovered_node() == &label->dom_node())
@ -91,7 +89,7 @@ bool Label::is_associated_label_hovered(LabelableNode& control)
}
// https://html.spec.whatwg.org/multipage/forms.html#labeled-control
Label* Label::label_for_control_node(LabelableNode& control)
Label const* Label::label_for_control_node(LabelableNode const& control)
{
if (!control.document().layout_node())
return nullptr;
@ -102,7 +100,7 @@ Label* Label::label_for_control_node(LabelableNode& control)
// whose ID is equal to the value of the for attribute, and the first such element in tree order is
// a labelable element, then that element is the label element's labeled control.
if (auto id = control.dom_node().attribute(HTML::AttributeNames::id); !id.is_empty()) {
Label* label = nullptr;
Label const* label = nullptr;
control.document().layout_node()->for_each_in_inclusive_subtree_of_type<Label>([&](auto& node) {
if (node.dom_node().for_() == id) {

12
Userland/Libraries/LibWeb/Layout/Label.h
View file

@ -16,20 +16,20 @@ public:
Label(DOM::Document&, HTML::HTMLLabelElement*, NonnullRefPtr<CSS::StyleProperties>);
virtual ~Label() override;
static bool is_inside_associated_label(LabelableNode&, const Gfx::IntPoint&);
static bool is_associated_label_hovered(LabelableNode&);
static bool is_inside_associated_label(LabelableNode const&, Gfx::IntPoint const&);
static bool is_associated_label_hovered(LabelableNode const&);
const HTML::HTMLLabelElement& dom_node() const { return static_cast<const HTML::HTMLLabelElement&>(*BlockContainer::dom_node()); }
HTML::HTMLLabelElement& dom_node() { return static_cast<HTML::HTMLLabelElement&>(*BlockContainer::dom_node()); }
void handle_mousedown_on_label(Badge<TextNode>, const Gfx::IntPoint&, unsigned button);
void handle_mouseup_on_label(Badge<TextNode>, const Gfx::IntPoint&, unsigned button);
void handle_mousemove_on_label(Badge<TextNode>, const Gfx::IntPoint&, unsigned button);
void handle_mousedown_on_label(Badge<Painting::TextPaintable>, const Gfx::IntPoint&, unsigned button);
void handle_mouseup_on_label(Badge<Painting::TextPaintable>, const Gfx::IntPoint&, unsigned button);
void handle_mousemove_on_label(Badge<Painting::TextPaintable>, const Gfx::IntPoint&, unsigned button);
private:
virtual bool is_label() const override { return true; }
static Label* label_for_control_node(LabelableNode&);
static Label const* label_for_control_node(LabelableNode const&);
LabelableNode* labeled_control();
bool m_tracking_mouse { false };

22
Userland/Libraries/LibWeb/Layout/LabelableNode.cpp Normal file
View file

@ -0,0 +1,22 @@
/*
* Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibWeb/Layout/LabelableNode.h>
#include <LibWeb/Painting/LabelablePaintable.h>
namespace Web::Layout {
Painting::LabelablePaintable* LabelableNode::paintable()
{
return static_cast<Painting::LabelablePaintable*>(ReplacedBox::paintable());
}
Painting::LabelablePaintable const* LabelableNode::paintable() const
{
return static_cast<Painting::LabelablePaintable const*>(ReplacedBox::paintable());
}
}

5
Userland/Libraries/LibWeb/Layout/LabelableNode.h
View file

@ -13,9 +13,8 @@ namespace Web::Layout {
class LabelableNode : public ReplacedBox {
public:
virtual void handle_associated_label_mousedown(Badge<Label>) { }
virtual void handle_associated_label_mouseup(Badge<Label>) { }
virtual void handle_associated_label_mousemove(Badge<Label>, [[maybe_unused]] bool is_inside_node_or_label) { }
Painting::LabelablePaintable* paintable();
Painting::LabelablePaintable const* paintable() const;
protected:
LabelableNode(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style)

26
Userland/Libraries/LibWeb/Layout/Node.cpp
View file

@ -514,32 +514,6 @@ void NodeWithStyle::apply_style(const CSS::StyleProperties& specified_style)
}
}
void Node::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned)
{
}
void Node::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned)
{
}
void Node::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned)
{
}
bool Node::handle_mousewheel(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned, int wheel_delta_x, int wheel_delta_y)
{
if (auto* containing_block = this->containing_block()) {
if (!containing_block->is_scrollable())
return false;
auto new_offset = containing_block->scroll_offset();
new_offset.translate_by(wheel_delta_x, wheel_delta_y);
containing_block->set_scroll_offset(new_offset);
return true;
}
return false;
}
bool Node::is_root_element() const
{
if (is_anonymous())

7
Userland/Libraries/LibWeb/Layout/Node.h
View file

@ -83,13 +83,6 @@ public:
bool is_inline_block() const;
virtual bool wants_mouse_events() const { return false; }
virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers);
virtual void handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers);
virtual void handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned buttons, unsigned modifiers);
virtual bool handle_mousewheel(Badge<EventHandler>, const Gfx::IntPoint&, unsigned buttons, unsigned modifiers, int wheel_delta_x, int wheel_delta_y);
virtual void paint_fragment(PaintContext&, const LineBoxFragment&, Painting::PaintPhase) const { }
// These are used to optimize hot is<T> variants for some classes where dynamic_cast is too slow.

87
Userland/Libraries/LibWeb/Layout/RadioButton.cpp
View file

@ -27,93 +27,6 @@ RadioButton::~RadioButton()
{
}
void RadioButton::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned)
{
if (button != GUI::MouseButton::Primary || !dom_node().enabled())
return;
m_being_pressed = true;
set_needs_display();
m_tracking_mouse = true;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(this);
}
void RadioButton::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
if (!m_tracking_mouse || button != GUI::MouseButton::Primary || !dom_node().enabled())
return;
// NOTE: Changing the checked state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
bool is_inside_node_or_label = enclosing_int_rect(paint_box()->absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Label::is_inside_associated_label(*this, position);
if (is_inside_node_or_label)
set_checked_within_group();
m_being_pressed = false;
m_tracking_mouse = false;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(nullptr);
}
void RadioButton::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned)
{
if (!m_tracking_mouse || !dom_node().enabled())
return;
bool is_inside_node_or_label = enclosing_int_rect(paint_box()->absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Label::is_inside_associated_label(*this, position);
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
void RadioButton::handle_associated_label_mousedown(Badge<Label>)
{
m_being_pressed = true;
set_needs_display();
}
void RadioButton::handle_associated_label_mouseup(Badge<Label>)
{
// NOTE: Changing the checked state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
set_checked_within_group();
m_being_pressed = false;
}
void RadioButton::handle_associated_label_mousemove(Badge<Label>, bool is_inside_node_or_label)
{
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
void RadioButton::set_checked_within_group()
{
if (dom_node().checked())
return;
dom_node().set_checked(true, HTML::HTMLInputElement::ChangeSource::User);
String name = dom_node().name();
document().for_each_in_inclusive_subtree_of_type<HTML::HTMLInputElement>([&](auto& element) {
if (element.checked() && (element.layout_node() != this) && (element.name() == name))
element.set_checked(false, HTML::HTMLInputElement::ChangeSource::User);
return IterationDecision::Continue;
});
}
RefPtr<Painting::Paintable> RadioButton::create_paintable() const
{
return Painting::RadioButtonPaintable::create(*this);

18
Userland/Libraries/LibWeb/Layout/RadioButton.h
View file

@ -19,24 +19,8 @@ public:
const HTML::HTMLInputElement& dom_node() const { return static_cast<const HTML::HTMLInputElement&>(LabelableNode::dom_node()); }
HTML::HTMLInputElement& dom_node() { return static_cast<HTML::HTMLInputElement&>(LabelableNode::dom_node()); }
virtual RefPtr<Painting::Paintable> create_paintable() const override;
bool being_pressed() const { return m_being_pressed; }
private:
virtual bool wants_mouse_events() const override { return true; }
virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned buttons, unsigned modifiers) override;
virtual void handle_associated_label_mousedown(Badge<Label>) override;
virtual void handle_associated_label_mouseup(Badge<Label>) override;
virtual void handle_associated_label_mousemove(Badge<Label>, bool is_inside_node_or_label) override;
void set_checked_within_group();
bool m_being_pressed { false };
bool m_tracking_mouse { false };
virtual RefPtr<Painting::Paintable> create_paintable() const override;
};
}

35
Userland/Libraries/LibWeb/Layout/TextNode.cpp
View file

@ -241,41 +241,6 @@ void TextNode::compute_text_for_rendering(bool collapse, bool previous_is_empty_
m_text_for_rendering = builder.to_string();
}
bool TextNode::wants_mouse_events() const
{
return first_ancestor_of_type<Label>();
}
void TextNode::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
auto* label = first_ancestor_of_type<Label>();
if (!label)
return;
label->handle_mousedown_on_label({}, position, button);
browsing_context().event_handler().set_mouse_event_tracking_layout_node(this);
}
void TextNode::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
auto* label = first_ancestor_of_type<Label>();
if (!label)
return;
// NOTE: Changing the state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
label->handle_mouseup_on_label({}, position, button);
browsing_context().event_handler().set_mouse_event_tracking_layout_node(nullptr);
}
void TextNode::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
auto* label = first_ancestor_of_type<Label>();
if (!label)
return;
label->handle_mousemove_on_label({}, position, button);
}
TextNode::ChunkIterator::ChunkIterator(StringView text, LayoutMode layout_mode, bool wrap_lines, bool respect_linebreaks)
: m_layout_mode(layout_mode)
, m_wrap_lines(wrap_lines)

4
Userland/Libraries/LibWeb/Layout/TextNode.h
View file

@ -56,10 +56,6 @@ public:
private:
virtual bool is_text_node() const final { return true; }
virtual bool wants_mouse_events() const override;
virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
void paint_cursor_if_needed(PaintContext&, const LineBoxFragment&) const;
void paint_text_decoration(Gfx::Painter&, LineBoxFragment const&) const;

27
Userland/Libraries/LibWeb/Page/EventHandler.cpp
View file

@ -16,6 +16,7 @@
#include <LibWeb/Layout/InitialContainingBlock.h>
#include <LibWeb/Page/EventHandler.h>
#include <LibWeb/Page/Page.h>
#include <LibWeb/Painting/Paintable.h>
#include <LibWeb/UIEvents/EventNames.h>
#include <LibWeb/UIEvents/KeyboardEvent.h>
#include <LibWeb/UIEvents/MouseEvent.h>
@ -123,9 +124,10 @@ bool EventHandler::handle_mousewheel(const Gfx::IntPoint& position, unsigned int
// FIXME: Support wheel events in nested browsing contexts.
auto result = layout_root()->hit_test(position, Layout::HitTestType::Exact);
if (result.layout_node) {
if (result.layout_node->handle_mousewheel({}, position, buttons, modifiers, wheel_delta_x, wheel_delta_y))
return true;
if (result.layout_node
&& result.layout_node->paintable()
&& result.layout_node->paintable()->handle_mousewheel({}, position, buttons, modifiers, wheel_delta_x, wheel_delta_y)) {
return true;
}
if (auto* page = m_browsing_context.page()) {
@ -142,7 +144,7 @@ bool EventHandler::handle_mouseup(const Gfx::IntPoint& position, unsigned button
return false;
if (m_mouse_event_tracking_layout_node) {
m_mouse_event_tracking_layout_node->handle_mouseup({}, position, button, modifiers);
m_mouse_event_tracking_layout_node->paintable()->handle_mouseup({}, position, button, modifiers);
return true;
}
@ -150,8 +152,8 @@ bool EventHandler::handle_mouseup(const Gfx::IntPoint& position, unsigned button
auto result = layout_root()->hit_test(position, Layout::HitTestType::Exact);
if (result.layout_node && result.layout_node->wants_mouse_events()) {
result.layout_node->handle_mouseup({}, position, button, modifiers);
if (result.layout_node && result.layout_node->paintable() && result.layout_node->paintable()->wants_mouse_events()) {
result.layout_node->paintable()->handle_mouseup({}, position, button, modifiers);
// Things may have changed as a consequence of Layout::Node::handle_mouseup(). Hit test again.
if (!layout_root())
@ -186,7 +188,7 @@ bool EventHandler::handle_mousedown(const Gfx::IntPoint& position, unsigned butt
return false;
if (m_mouse_event_tracking_layout_node) {
m_mouse_event_tracking_layout_node->handle_mousedown({}, position, button, modifiers);
m_mouse_event_tracking_layout_node->paintable()->handle_mousedown({}, position, button, modifiers);
return true;
}
@ -207,8 +209,8 @@ bool EventHandler::handle_mousedown(const Gfx::IntPoint& position, unsigned butt
node = result.layout_node->dom_node();
document->set_hovered_node(node);
if (result.layout_node->wants_mouse_events()) {
result.layout_node->handle_mousedown({}, position, button, modifiers);
if (result.layout_node->paintable() && result.layout_node->paintable()->wants_mouse_events()) {
result.layout_node->paintable()->handle_mousedown({}, position, button, modifiers);
return true;
}
@ -304,7 +306,7 @@ bool EventHandler::handle_mousemove(const Gfx::IntPoint& position, unsigned butt
return false;
if (m_mouse_event_tracking_layout_node) {
m_mouse_event_tracking_layout_node->handle_mousemove({}, position, buttons, modifiers);
m_mouse_event_tracking_layout_node->paintable()->handle_mousemove({}, position, buttons, modifiers);
return true;
}
@ -316,10 +318,9 @@ bool EventHandler::handle_mousemove(const Gfx::IntPoint& position, unsigned butt
auto result = layout_root()->hit_test(position, Layout::HitTestType::Exact);
const HTML::HTMLAnchorElement* hovered_link_element = nullptr;
if (result.layout_node) {
if (result.layout_node->wants_mouse_events()) {
if (result.layout_node->paintable() && result.layout_node->paintable()->wants_mouse_events()) {
document.set_hovered_node(result.layout_node->dom_node());
result.layout_node->handle_mousemove({}, position, buttons, modifiers);
result.layout_node->paintable()->handle_mousemove({}, position, buttons, modifiers);
// FIXME: It feels a bit aggressive to always update the cursor like this.
if (auto* page = m_browsing_context.page())
page->client().page_did_request_cursor_change(Gfx::StandardCursor::None);

87
Userland/Libraries/LibWeb/Painting/ButtonPaintable.cpp
View file

@ -4,8 +4,11 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibGUI/Event.h>
#include <LibWeb/HTML/BrowsingContext.h>
#include <LibWeb/HTML/HTMLImageElement.h>
#include <LibWeb/Layout/ButtonBox.h>
#include <LibWeb/Layout/Label.h>
#include <LibWeb/Painting/ButtonPaintable.h>
namespace Web::Painting {
@ -16,7 +19,7 @@ NonnullRefPtr<ButtonPaintable> ButtonPaintable::create(Layout::ButtonBox const&
}
ButtonPaintable::ButtonPaintable(Layout::ButtonBox const& layout_box)
: PaintableBox(layout_box)
: LabelablePaintable(layout_box)
{
}
@ -25,6 +28,11 @@ Layout::ButtonBox const& ButtonPaintable::layout_box() const
return static_cast<Layout::ButtonBox const&>(layout_node());
}
Layout::ButtonBox& ButtonPaintable::layout_box()
{
return static_cast<Layout::ButtonBox&>(layout_node());
}
void ButtonPaintable::paint(PaintContext& context, PaintPhase phase) const
{
if (!is_visible())
@ -34,10 +42,85 @@ void ButtonPaintable::paint(PaintContext& context, PaintPhase phase) const
if (phase == PaintPhase::Foreground) {
auto text_rect = enclosing_int_rect(absolute_rect());
if (layout_box().being_pressed())
if (m_being_pressed)
text_rect.translate_by(1, 1);
context.painter().draw_text(text_rect, layout_box().dom_node().value(), layout_box().font(), Gfx::TextAlignment::Center, computed_values().color());
}
}
void ButtonPaintable::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned)
{
if (button != GUI::MouseButton::Primary || !layout_box().dom_node().enabled())
return;
m_being_pressed = true;
set_needs_display();
m_tracking_mouse = true;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(&layout_box());
}
void ButtonPaintable::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
if (!m_tracking_mouse || button != GUI::MouseButton::Primary || !layout_box().dom_node().enabled())
return;
// NOTE: Handling the click may run arbitrary JS, which could disappear this node.
NonnullRefPtr protected_this = *this;
NonnullRefPtr protected_browsing_context = browsing_context();
bool is_inside_node_or_label = enclosing_int_rect(absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Layout::Label::is_inside_associated_label(layout_box(), position);
if (is_inside_node_or_label)
const_cast<Layout::ButtonBox&>(layout_box()).dom_node().did_click_button({});
m_being_pressed = false;
m_tracking_mouse = false;
protected_browsing_context->event_handler().set_mouse_event_tracking_layout_node(nullptr);
}
void ButtonPaintable::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned)
{
if (!m_tracking_mouse || !layout_box().dom_node().enabled())
return;
bool is_inside_node_or_label = enclosing_int_rect(absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Layout::Label::is_inside_associated_label(layout_box(), position);
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
void ButtonPaintable::handle_associated_label_mousedown(Badge<Layout::Label>)
{
m_being_pressed = true;
set_needs_display();
}
void ButtonPaintable::handle_associated_label_mouseup(Badge<Layout::Label>)
{
// NOTE: Handling the click may run arbitrary JS, which could disappear this node.
NonnullRefPtr protected_this = *this;
NonnullRefPtr protected_browsing_context = browsing_context();
layout_box().dom_node().did_click_button({});
m_being_pressed = false;
}
void ButtonPaintable::handle_associated_label_mousemove(Badge<Layout::Label>, bool is_inside_node_or_label)
{
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
}

17
Userland/Libraries/LibWeb/Painting/ButtonPaintable.h
View file

@ -7,20 +7,33 @@
#pragma once
#include <LibWeb/Layout/ButtonBox.h>
#include <LibWeb/Painting/Paintable.h>
#include <LibWeb/Painting/LabelablePaintable.h>
namespace Web::Painting {
class ButtonPaintable final : public PaintableBox {
class ButtonPaintable final : public LabelablePaintable {
public:
static NonnullRefPtr<ButtonPaintable> create(Layout::ButtonBox const&);
virtual void paint(PaintContext&, PaintPhase) const override;
Layout::ButtonBox const& layout_box() const;
Layout::ButtonBox& layout_box();
virtual bool wants_mouse_events() const override { return true; }
virtual void handle_mousedown(Badge<EventHandler>, Gfx::IntPoint const&, unsigned button, unsigned modifiers) override;
virtual void handle_mouseup(Badge<EventHandler>, Gfx::IntPoint const&, unsigned button, unsigned modifiers) override;
virtual void handle_mousemove(Badge<EventHandler>, Gfx::IntPoint const&, unsigned buttons, unsigned modifiers) override;
private:
ButtonPaintable(Layout::ButtonBox const&);
virtual void handle_associated_label_mousedown(Badge<Layout::Label>) override;
virtual void handle_associated_label_mouseup(Badge<Layout::Label>) override;
virtual void handle_associated_label_mousemove(Badge<Layout::Label>, bool is_inside_node_or_label) override;
bool m_being_pressed { false };
bool m_tracking_mouse { false };
};
}

93
Userland/Libraries/LibWeb/Painting/CheckBoxPaintable.cpp
View file

@ -4,9 +4,12 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibGUI/Event.h>
#include <LibGfx/StylePainter.h>
#include <LibWeb/HTML/BrowsingContext.h>
#include <LibWeb/HTML/HTMLImageElement.h>
#include <LibWeb/Layout/CheckBox.h>
#include <LibWeb/Layout/Label.h>
#include <LibWeb/Painting/CheckBoxPaintable.h>
namespace Web::Painting {
@ -17,7 +20,7 @@ NonnullRefPtr<CheckBoxPaintable> CheckBoxPaintable::create(Layout::CheckBox cons
}
CheckBoxPaintable::CheckBoxPaintable(Layout::CheckBox const& layout_box)
: PaintableBox(layout_box)
: LabelablePaintable(layout_box)
{
}
@ -26,6 +29,11 @@ Layout::CheckBox const& CheckBoxPaintable::layout_box() const
return static_cast<Layout::CheckBox const&>(layout_node());
}
Layout::CheckBox& CheckBoxPaintable::layout_box()
{
return static_cast<Layout::CheckBox&>(layout_node());
}
void CheckBoxPaintable::paint(PaintContext& context, PaintPhase phase) const
{
if (!is_visible())
@ -34,7 +42,88 @@ void CheckBoxPaintable::paint(PaintContext& context, PaintPhase phase) const
PaintableBox::paint(context, phase);
if (phase == PaintPhase::Foreground)
Gfx::StylePainter::paint_check_box(context.painter(), enclosing_int_rect(absolute_rect()), context.palette(), layout_box().dom_node().enabled(), layout_box().dom_node().checked(), layout_box().being_pressed());
Gfx::StylePainter::paint_check_box(context.painter(), enclosing_int_rect(absolute_rect()), context.palette(), layout_box().dom_node().enabled(), layout_box().dom_node().checked(), m_being_pressed);
}
void CheckBoxPaintable::handle_mousedown(Badge<EventHandler>, Gfx::IntPoint const&, unsigned button, unsigned)
{
if (button != GUI::MouseButton::Primary || !layout_box().dom_node().enabled())
return;
m_being_pressed = true;
set_needs_display();
m_tracking_mouse = true;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(&layout_box());
}
void CheckBoxPaintable::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
if (!m_tracking_mouse || button != GUI::MouseButton::Primary || !layout_box().dom_node().enabled())
return;
// NOTE: Changing the checked state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
bool is_inside_node_or_label = enclosing_int_rect(absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Layout::Label::is_inside_associated_label(layout_box(), position);
if (is_inside_node_or_label) {
layout_box().dom_node().did_click_checkbox({});
layout_box().dom_node().set_checked(!layout_box().dom_node().checked(), HTML::HTMLInputElement::ChangeSource::User);
}
m_being_pressed = false;
m_tracking_mouse = false;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(nullptr);
}
void CheckBoxPaintable::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned)
{
if (!m_tracking_mouse || !layout_box().dom_node().enabled())
return;
bool is_inside_node_or_label = enclosing_int_rect(absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Layout::Label::is_inside_associated_label(layout_box(), position);
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
void CheckBoxPaintable::handle_associated_label_mousedown(Badge<Layout::Label>)
{
if (!layout_box().dom_node().enabled())
return;
m_being_pressed = true;
set_needs_display();
}
void CheckBoxPaintable::handle_associated_label_mouseup(Badge<Layout::Label>)
{
if (!layout_box().dom_node().enabled())
return;
// NOTE: Changing the checked state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
layout_box().dom_node().did_click_checkbox({});
layout_box().dom_node().set_checked(!layout_box().dom_node().checked(), HTML::HTMLInputElement::ChangeSource::User);
m_being_pressed = false;
}
void CheckBoxPaintable::handle_associated_label_mousemove(Badge<Layout::Label>, bool is_inside_node_or_label)
{
if (m_being_pressed == is_inside_node_or_label || !layout_box().dom_node().enabled())
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
}

17
Userland/Libraries/LibWeb/Painting/CheckBoxPaintable.h
View file

@ -7,20 +7,33 @@
#pragma once
#include <LibWeb/Layout/CheckBox.h>
#include <LibWeb/Painting/Paintable.h>
#include <LibWeb/Painting/LabelablePaintable.h>
namespace Web::Painting {
class CheckBoxPaintable final : public PaintableBox {
class CheckBoxPaintable final : public LabelablePaintable {
public:
static NonnullRefPtr<CheckBoxPaintable> create(Layout::CheckBox const&);
virtual void paint(PaintContext&, PaintPhase) const override;
Layout::CheckBox const& layout_box() const;
Layout::CheckBox& layout_box();
virtual bool wants_mouse_events() const override { return true; }
virtual void handle_mousedown(Badge<EventHandler>, Gfx::IntPoint const&, unsigned button, unsigned modifiers) override;
virtual void handle_mouseup(Badge<EventHandler>, Gfx::IntPoint const&, unsigned button, unsigned modifiers) override;
virtual void handle_mousemove(Badge<EventHandler>, Gfx::IntPoint const&, unsigned buttons, unsigned modifiers) override;
private:
CheckBoxPaintable(Layout::CheckBox const&);
virtual void handle_associated_label_mousedown(Badge<Layout::Label>) override;
virtual void handle_associated_label_mouseup(Badge<Layout::Label>) override;
virtual void handle_associated_label_mousemove(Badge<Layout::Label>, bool is_inside_node_or_label) override;
bool m_being_pressed { false };
bool m_tracking_mouse { false };
};
}

26
Userland/Libraries/LibWeb/Painting/LabelablePaintable.cpp Normal file
View file

@ -0,0 +1,26 @@
/*
* Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibWeb/Painting/LabelablePaintable.h>
namespace Web::Painting {
Layout::LabelableNode const& LabelablePaintable::layout_box() const
{
return static_cast<Layout::LabelableNode const&>(PaintableBox::layout_box());
}
Layout::LabelableNode& LabelablePaintable::layout_box()
{
return static_cast<Layout::LabelableNode&>(PaintableBox::layout_box());
}
LabelablePaintable::LabelablePaintable(Layout::LabelableNode const& layout_node)
: PaintableBox(layout_node)
{
}
}

27
Userland/Libraries/LibWeb/Painting/LabelablePaintable.h Normal file
View file

@ -0,0 +1,27 @@
/*
* Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <LibWeb/Layout/LabelableNode.h>
#include <LibWeb/Painting/Paintable.h>
namespace Web::Painting {
class LabelablePaintable : public PaintableBox {
public:
Layout::LabelableNode const& layout_box() const;
Layout::LabelableNode& layout_box();
virtual void handle_associated_label_mousedown(Badge<Layout::Label>) { }
virtual void handle_associated_label_mouseup(Badge<Layout::Label>) { }
virtual void handle_associated_label_mousemove(Badge<Layout::Label>, [[maybe_unused]] bool is_inside_node_or_label) { }
protected:
LabelablePaintable(Layout::LabelableNode const&);
};
}

48
Userland/Libraries/LibWeb/Painting/Paintable.cpp
View file

@ -287,4 +287,52 @@ void PaintableWithLines::paint(PaintContext& context, PaintPhase phase) const
}
}
void Paintable::handle_mousedown(Badge<EventHandler>, Gfx::IntPoint const&, unsigned, unsigned)
{
}
void Paintable::handle_mouseup(Badge<EventHandler>, Gfx::IntPoint const&, unsigned, unsigned)
{
}
void Paintable::handle_mousemove(Badge<EventHandler>, Gfx::IntPoint const&, unsigned, unsigned)
{
}
bool Paintable::handle_mousewheel(Badge<EventHandler>, Gfx::IntPoint const&, unsigned, unsigned, int wheel_delta_x, int wheel_delta_y)
{
if (auto* containing_block = layout_node().containing_block()) {
if (!containing_block->is_scrollable())
return false;
auto new_offset = containing_block->scroll_offset();
new_offset.translate_by(wheel_delta_x, wheel_delta_y);
// FIXME: This const_cast is gross.
// FIXME: Scroll offset shouldn't live in the layout tree.
const_cast<Layout::BlockContainer*>(containing_block)->set_scroll_offset(new_offset);
return true;
}
return false;
}
bool PaintableWithLines::handle_mousewheel(Badge<EventHandler>, Gfx::IntPoint const&, unsigned, unsigned, int wheel_delta_x, int wheel_delta_y)
{
if (!layout_box().is_scrollable())
return false;
auto new_offset = layout_box().scroll_offset();
new_offset.translate_by(wheel_delta_x, wheel_delta_y);
const_cast<Layout::BlockContainer&>(layout_box()).set_scroll_offset(new_offset);
return true;
}
Layout::BlockContainer const& PaintableWithLines::layout_box() const
{
return static_cast<Layout::BlockContainer const&>(PaintableBox::layout_box());
}
Layout::BlockContainer& PaintableWithLines::layout_box()
{
return static_cast<Layout::BlockContainer&>(PaintableBox::layout_box());
}
}

22
Userland/Libraries/LibWeb/Painting/Paintable.h
View file

@ -25,9 +25,22 @@ public:
virtual void before_children_paint(PaintContext&, PaintPhase) const { }
virtual void after_children_paint(PaintContext&, PaintPhase) const { }
virtual bool wants_mouse_events() const { return false; }
virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers);
virtual void handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers);
virtual void handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned buttons, unsigned modifiers);
virtual bool handle_mousewheel(Badge<EventHandler>, const Gfx::IntPoint&, unsigned buttons, unsigned modifiers, int wheel_delta_x, int wheel_delta_y);
Layout::Node const& layout_node() const { return m_layout_node; }
Layout::Node& layout_node() { return const_cast<Layout::Node&>(m_layout_node); }
auto const& computed_values() const { return m_layout_node.computed_values(); }
HTML::BrowsingContext const& browsing_context() const { return m_layout_node.browsing_context(); }
HTML::BrowsingContext& browsing_context() { return layout_node().browsing_context(); }
void set_needs_display() const { const_cast<Layout::Node&>(m_layout_node).set_needs_display(); }
protected:
explicit Paintable(Layout::Node const& layout_node)
: m_layout_node(layout_node)
@ -47,6 +60,7 @@ public:
bool is_visible() const { return layout_box().is_visible(); }
Layout::Box& layout_box() { return static_cast<Layout::Box&>(Paintable::layout_node()); }
Layout::Box const& layout_box() const { return static_cast<Layout::Box const&>(Paintable::layout_node()); }
auto const& box_model() const { return layout_box().box_model(); }
@ -134,7 +148,10 @@ public:
StackingContext* enclosing_stacking_context();
DOM::Node const* dom_node() const { return layout_box().dom_node(); }
DOM::Node* dom_node() { return layout_box().dom_node(); }
DOM::Document const& document() const { return layout_box().document(); }
DOM::Document& document() { return layout_box().document(); }
virtual void before_children_paint(PaintContext&, PaintPhase) const override;
virtual void after_children_paint(PaintContext&, PaintPhase) const override;
@ -160,6 +177,9 @@ public:
}
virtual ~PaintableWithLines() override;
Layout::BlockContainer const& layout_box() const;
Layout::BlockContainer& layout_box();
Vector<Layout::LineBox> const& line_boxes() const { return m_line_boxes; }
void set_line_boxes(Vector<Layout::LineBox>&& line_boxes) { m_line_boxes = move(line_boxes); }
@ -175,6 +195,8 @@ public:
}
virtual void paint(PaintContext&, PaintPhase) const override;
virtual bool wants_mouse_events() const override { return false; }
virtual bool handle_mousewheel(Badge<EventHandler>, const Gfx::IntPoint&, unsigned buttons, unsigned modifiers, int wheel_delta_x, int wheel_delta_y) override;
private:
PaintableWithLines(Layout::BlockContainer const&);

100
Userland/Libraries/LibWeb/Painting/RadioButtonPaintable.cpp
View file

@ -4,8 +4,12 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibGUI/Event.h>
#include <LibGfx/StylePainter.h>
#include <LibWeb/DOM/Document.h>
#include <LibWeb/HTML/BrowsingContext.h>
#include <LibWeb/HTML/HTMLImageElement.h>
#include <LibWeb/Layout/Label.h>
#include <LibWeb/Layout/RadioButton.h>
#include <LibWeb/Painting/RadioButtonPaintable.h>
@ -17,7 +21,7 @@ NonnullRefPtr<RadioButtonPaintable> RadioButtonPaintable::create(Layout::RadioBu
}
RadioButtonPaintable::RadioButtonPaintable(Layout::RadioButton const& layout_box)
: PaintableBox(layout_box)
: LabelablePaintable(layout_box)
{
}
@ -26,6 +30,11 @@ Layout::RadioButton const& RadioButtonPaintable::layout_box() const
return static_cast<Layout::RadioButton const&>(layout_node());
}
Layout::RadioButton& RadioButtonPaintable::layout_box()
{
return static_cast<Layout::RadioButton&>(layout_node());
}
void RadioButtonPaintable::paint(PaintContext& context, PaintPhase phase) const
{
if (!is_visible())
@ -34,7 +43,94 @@ void RadioButtonPaintable::paint(PaintContext& context, PaintPhase phase) const
PaintableBox::paint(context, phase);
if (phase == PaintPhase::Foreground)
Gfx::StylePainter::paint_radio_button(context.painter(), enclosing_int_rect(absolute_rect()), context.palette(), layout_box().dom_node().checked(), layout_box().being_pressed());
Gfx::StylePainter::paint_radio_button(context.painter(), enclosing_int_rect(absolute_rect()), context.palette(), layout_box().dom_node().checked(), m_being_pressed);
}
void RadioButtonPaintable::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned)
{
if (button != GUI::MouseButton::Primary || !layout_box().dom_node().enabled())
return;
m_being_pressed = true;
set_needs_display();
m_tracking_mouse = true;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(&layout_box());
}
void RadioButtonPaintable::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
if (!m_tracking_mouse || button != GUI::MouseButton::Primary || !layout_box().dom_node().enabled())
return;
// NOTE: Changing the checked state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
bool is_inside_node_or_label = enclosing_int_rect(absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Layout::Label::is_inside_associated_label(layout_box(), position);
if (is_inside_node_or_label)
set_checked_within_group();
m_being_pressed = false;
m_tracking_mouse = false;
browsing_context().event_handler().set_mouse_event_tracking_layout_node(nullptr);
}
void RadioButtonPaintable::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned)
{
if (!m_tracking_mouse || !layout_box().dom_node().enabled())
return;
bool is_inside_node_or_label = enclosing_int_rect(absolute_rect()).contains(position);
if (!is_inside_node_or_label)
is_inside_node_or_label = Layout::Label::is_inside_associated_label(layout_box(), position);
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
void RadioButtonPaintable::handle_associated_label_mousedown(Badge<Layout::Label>)
{
m_being_pressed = true;
set_needs_display();
}
void RadioButtonPaintable::handle_associated_label_mouseup(Badge<Layout::Label>)
{
// NOTE: Changing the checked state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
set_checked_within_group();
m_being_pressed = false;
}
void RadioButtonPaintable::handle_associated_label_mousemove(Badge<Layout::Label>, bool is_inside_node_or_label)
{
if (m_being_pressed == is_inside_node_or_label)
return;
m_being_pressed = is_inside_node_or_label;
set_needs_display();
}
void RadioButtonPaintable::set_checked_within_group()
{
if (layout_box().dom_node().checked())
return;
layout_box().dom_node().set_checked(true, HTML::HTMLInputElement::ChangeSource::User);
String name = layout_box().dom_node().name();
document().for_each_in_inclusive_subtree_of_type<HTML::HTMLInputElement>([&](auto& element) {
if (element.checked() && (element.paintable() != this) && (element.name() == name))
element.set_checked(false, HTML::HTMLInputElement::ChangeSource::User);
return IterationDecision::Continue;
});
}
}

19
Userland/Libraries/LibWeb/Painting/RadioButtonPaintable.h
View file

@ -7,20 +7,35 @@
#pragma once
#include <LibWeb/Layout/RadioButton.h>
#include <LibWeb/Painting/Paintable.h>
#include <LibWeb/Painting/LabelablePaintable.h>
namespace Web::Painting {
class RadioButtonPaintable final : public PaintableBox {
class RadioButtonPaintable final : public LabelablePaintable {
public:
static NonnullRefPtr<RadioButtonPaintable> create(Layout::RadioButton const&);
virtual void paint(PaintContext&, PaintPhase) const override;
Layout::RadioButton const& layout_box() const;
Layout::RadioButton& layout_box();
virtual bool wants_mouse_events() const override { return true; }
virtual void handle_mousedown(Badge<EventHandler>, Gfx::IntPoint const&, unsigned button, unsigned modifiers) override;
virtual void handle_mouseup(Badge<EventHandler>, Gfx::IntPoint const&, unsigned button, unsigned modifiers) override;
virtual void handle_mousemove(Badge<EventHandler>, Gfx::IntPoint const&, unsigned buttons, unsigned modifiers) override;
private:
RadioButtonPaintable(Layout::RadioButton const&);
virtual void handle_associated_label_mousedown(Badge<Layout::Label>) override;
virtual void handle_associated_label_mouseup(Badge<Layout::Label>) override;
virtual void handle_associated_label_mousemove(Badge<Layout::Label>, bool is_inside_node_or_label) override;
void set_checked_within_group();
bool m_being_pressed { false };
bool m_tracking_mouse { false };
};
}

35
Userland/Libraries/LibWeb/Painting/TextPaintable.cpp
View file

@ -21,4 +21,39 @@ TextPaintable::TextPaintable(Layout::TextNode const& layout_node)
{
}
bool TextPaintable::wants_mouse_events() const
{
return layout_node().first_ancestor_of_type<Layout::Label>();
}
void TextPaintable::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
auto* label = layout_node().first_ancestor_of_type<Layout::Label>();
if (!label)
return;
const_cast<Layout::Label*>(label)->handle_mousedown_on_label({}, position, button);
const_cast<HTML::BrowsingContext&>(browsing_context()).event_handler().set_mouse_event_tracking_layout_node(&const_cast<Layout::TextNode&>(layout_node()));
}
void TextPaintable::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
auto* label = layout_node().first_ancestor_of_type<Layout::Label>();
if (!label)
return;
// NOTE: Changing the state of the DOM node may run arbitrary JS, which could disappear this node.
NonnullRefPtr protect = *this;
const_cast<Layout::Label*>(label)->handle_mouseup_on_label({}, position, button);
const_cast<HTML::BrowsingContext&>(browsing_context()).event_handler().set_mouse_event_tracking_layout_node(nullptr);
}
void TextPaintable::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{
auto* label = layout_node().first_ancestor_of_type<Layout::Label>();
if (!label)
return;
const_cast<Layout::Label*>(label)->handle_mousemove_on_label({}, position, button);
}
}

5
Userland/Libraries/LibWeb/Painting/TextPaintable.h
View file

@ -16,6 +16,11 @@ public:
Layout::TextNode const& layout_node() const { return static_cast<Layout::TextNode const&>(Paintable::layout_node()); }
virtual bool wants_mouse_events() const override;
virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
virtual void handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
private:
explicit TextPaintable(Layout::TextNode const&);
};