Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 15:43:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/HTML/HTMLInputElement.h

416 lines
17 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 13:19:50 +02:00
* Copyright (c) 2018-2022, Andreas Kling <andreas@ladybird.org>
LibWeb: Reflect only known values for <input> element's type attribute
2022-02-17 21:22:36 +00:00
* Copyright (c) 2022, Adam Hodgen <ant1441@gmail.com>
LibWeb: Add basic input range rendering
2023-12-11 18:00:06 +01:00
* Copyright (c) 2023, Bastiaan van der Plaat <bastiaan.v.d.plaat@gmail.com>
Meta: Update my email address everywhere
2024-11-01 12:14:53 +01:00
* Copyright (c) 2024, Jelle Raaijmakers <jelle@ladybird.org>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*/
LibHTML: Implement basic <form> and <input> element support This patch adds "submit" inputs and default (text box) inputs, as well as form elements that can be submitted. Layout of input elements is implemented via a new LayoutWidget class that allows you to put an arbitrary GWidget in the layout tree. At the moment, the DOM node sets the initial size of the LayoutWidget, and then the positioning is done by the normal layout algorithm. We also now support submitting a <form method="GET">, which does a full replacing load with a URL based on the form's action + a query string built from the name/value of input elements within the submitted form. This is pretty neat! :^)
2019-11-25 21:21:55 +01:00
#pragma once
LibWeb: Implement the `HTMLInputElement` pattern attribute
2025-02-27 10:13:52 +00:00
#include <LibRegex/Regex.h>
LibWeb: Begin implementing the HTMLInputElement 'image' type state This implements enough to represent <input type=image> with its loaded source image (or fallback to its alt text, if applicable). This does not implement acquring coordinates from user-activated click events on the image.
2024-02-18 21:12:14 -05:00
#include <LibWeb/DOM/DocumentLoadEventDelayer.h>
LibWeb: Allow non-HTMLInputElements to have did_edit_text_node() called HTMLTextAreaElement also needs to be told when its contained text node has been edited, so let's make this functionality work for anyone who extends the new EditableTextNodeOwner interface class.
2023-08-30 14:38:58 +01:00
#include <LibWeb/DOM/Text.h>
LibWeb: Enable EXPLICIT_SYMBOL_EXPORT
2025-07-19 19:35:33 -07:00
#include <LibWeb/Export.h>
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-03 23:39:53 -06:00
#include <LibWeb/FileAPI/FileList.h>
LibWeb: Support `autocomplete` attribute on form elements Implement proper support for the `autocomplete` attribute in `input`, `select` and `textarea` elements.
2025-02-09 15:56:54 +01:00
#include <LibWeb/HTML/AutocompleteElement.h>
LibWeb: Do not issue `change` event for every update of color input Per spec, the change event shall only be issued once the change is finally committed by the user, IE by closing the color picker window.
2024-03-02 18:06:44 +01:00
#include <LibWeb/HTML/ColorPickerUpdateState.h>
Ladybird+LibWeb+WebContent: Parse the <input type=file> accept attribute This parses the accept attribute value for file input types and passes it along to the browser chromes.
2024-03-14 12:26:00 -04:00
#include <LibWeb/HTML/FileFilter.h>
LibWeb: Add basic support for HTMLInputElement.form HTMLInputElement now inherits from FormAssociatedElement, which will be a common base for the handful of elements that need to track their owner form (and register with it for the form.elements collection.) At the moment, the owner form is assigned during DOM insertion/removal of an HTMLInputElement. I didn't implement any of the legacy behaviors defined by the HTML parsing spec yet.
2021-04-20 11:50:29 +02:00
#include <LibWeb/HTML/FormAssociatedElement.h>
LibWeb: Move HTML object model stuff into LibWeb/HTML/ Take a hint from SVG and more all the HTML classes into HTML instead of mixing them with the DOM classes.
2020-07-26 15:08:16 +02:00
#include <LibWeb/HTML/HTMLElement.h>
LibWeb: Implement popovertarget buttons
2025-01-14 15:15:38 +11:00
#include <LibWeb/HTML/PopoverInvokerElement.h>
LibWeb: Begin implementing the HTMLInputElement 'image' type state This implements enough to represent <input type=image> with its loaded source image (or fallback to its alt text, if applicable). This does not implement acquring coordinates from user-activated click events on the image.
2024-02-18 21:12:14 -05:00
#include <LibWeb/Layout/ImageProvider.h>
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-03 23:39:53 -06:00
#include <LibWeb/WebIDL/DOMException.h>
LibWeb: Add input and textarea minlength and maxlength support
2024-03-01 08:49:04 +01:00
#include <LibWeb/WebIDL/Types.h>
LibHTML: Implement basic <form> and <input> element support This patch adds "submit" inputs and default (text box) inputs, as well as form elements that can be submitted. Layout of input elements is implemented via a new LayoutWidget class that allows you to put an arbitrary GWidget in the layout tree. At the moment, the DOM node sets the initial size of the LayoutWidget, and then the positioning is done by the normal layout algorithm. We also now support submitting a <form method="GET">, which does a full replacing load with a URL based on the form's action + a query string built from the name/value of input elements within the submitted form. This is pretty neat! :^)
2019-11-25 21:21:55 +01:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02:00
namespace Web::HTML {
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
LibWeb: Reflect only known values for <input> element's type attribute
2022-02-17 21:22:36 +00:00
// https://html.spec.whatwg.org/multipage/input.html#attr-input-type
LibWeb: Add <input> value sanitiztion algorithm The value sanitiztion algorithm is defined for some states of the type attribute, and sanitizes the value of the 'value' attribute
2022-02-17 23:05:46 +00:00
#define ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTES \
LibWeb: Use correct value when parsing datetime-local input type
2024-09-10 10:43:22 +01:00
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("hidden", Hidden) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("text", Text) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("search", Search) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("tel", Telephone) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("url", URL) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("email", Email) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("password", Password) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("date", Date) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("month", Month) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("week", Week) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("time", Time) \
LibWeb: Add <input> value sanitiztion algorithm The value sanitiztion algorithm is defined for some states of the type attribute, and sanitizes the value of the 'value' attribute
2022-02-17 23:05:46 +00:00
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("datetime-local", LocalDateAndTime) \
LibWeb: Use correct value when parsing datetime-local input type
2024-09-10 10:43:22 +01:00
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("number", Number) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("range", Range) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("color", Color) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("checkbox", Checkbox) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("radio", RadioButton) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("file", FileUpload) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("submit", SubmitButton) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("image", ImageButton) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("reset", ResetButton) \
__ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE("button", Button)
LibWeb: Reflect only known values for <input> element's type attribute
2022-02-17 21:22:36 +00:00
LibWeb: Enable EXPLICIT_SYMBOL_EXPORT
2025-07-19 19:35:33 -07:00
class WEB_API HTMLInputElement final
LibWeb: Remove inheritance of FormAssociatedElement from HTMLElement HTMLObjectElement will need to be both a FormAssociatedElement and a BrowsingContextContainer. Currently, both of these classes inherit from HTMLElement. This can work in C++, but is generally frowned upon, and doesn't play particularly well with the rest of LibWeb. Instead, we can essentially revert commit 3bb5c62 to remove HTMLElement from FormAssociatedElement's hierarchy. This means that objects such as HTMLObjectElement individually inherit from FormAssociatedElement and HTMLElement now. Some caveats are: * FormAssociatedElement still needs to know when the HTMLElement is inserted into and removed from the DOM. This hook is automatically injected via a macro now, while still allowing classes like HTMLInputElement to also know when the element is inserted. * Casting from a DOM::Element to a FormAssociatedElement is now a sideways cast, rather than directly following an inheritance chain. This means static_cast cannot be used here; but we can safely use dynamic_cast since the only 2 instances of this already use RTTI to verify the cast.
2022-03-23 18:55:54 -04:00
: public HTMLElement
LibWeb: Subclass FormAssociatedElement text selection methods These are only relevant to HTMLInputElement and HTMLTextArea elements.
2024-08-30 17:22:58 +01:00
, public FormAssociatedTextControlElement
LibWeb: Implement popovertarget buttons
2025-01-14 15:15:38 +11:00
, public Layout::ImageProvider
LibWeb: Support `autocomplete` attribute on form elements Implement proper support for the `autocomplete` attribute in `input`, `select` and `textarea` elements.
2025-02-09 15:56:54 +01:00
, public PopoverInvokerElement
, public AutocompleteElement {
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
WEB_PLATFORM_OBJECT(HTMLInputElement, HTMLElement);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_DECLARE_ALLOCATOR(HTMLInputElement);
LibWeb: Support `autocomplete` attribute on form elements Implement proper support for the `autocomplete` attribute in `input`, `select` and `textarea` elements.
2025-02-09 15:56:54 +01:00
FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLInputElement);
AUTOCOMPLETE_ELEMENT(HTMLElement, HTMLInputElement);
LibWeb: Remove inheritance of FormAssociatedElement from HTMLElement HTMLObjectElement will need to be both a FormAssociatedElement and a BrowsingContextContainer. Currently, both of these classes inherit from HTMLElement. This can work in C++, but is generally frowned upon, and doesn't play particularly well with the rest of LibWeb. Instead, we can essentially revert commit 3bb5c62 to remove HTMLElement from FormAssociatedElement's hierarchy. This means that objects such as HTMLObjectElement individually inherit from FormAssociatedElement and HTMLElement now. Some caveats are: * FormAssociatedElement still needs to know when the HTMLElement is inserted into and removed from the DOM. This hook is automatically injected via a macro now, while still allowing classes like HTMLInputElement to also know when the element is inserted. * Casting from a DOM::Element to a FormAssociatedElement is now a sideways cast, rather than directly following an inheritance chain. This means static_cast cannot be used here; but we can safely use dynamic_cast since the only 2 instances of this already use RTTI to verify the cast.
2022-03-23 18:55:54 -04:00
LibHTML: Implement basic <form> and <input> element support This patch adds "submit" inputs and default (text box) inputs, as well as form elements that can be submitted. Layout of input elements is implemented via a new LayoutWidget class that allows you to put an arbitrary GWidget in the layout tree. At the moment, the DOM node sets the initial size of the LayoutWidget, and then the positioning is done by the normal layout algorithm. We also now support submitting a <form method="GET">, which does a full replacing load with a URL based on the form's action + a query string built from the name/value of input elements within the submitted form. This is pretty neat! :^)
2019-11-25 21:21:55 +01:00
public:
virtual ~HTMLInputElement() override;
LibWeb: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
virtual GC::Ptr<Layout::Node> create_layout_node(GC::Ref<CSS::ComputedProperties>) override;
LibWeb: Rename CSS::StyleProperties => CSS::ComputedProperties Now that StyleProperties is only used to hold computed properties, let's name it ComputedProperties.
2024-12-20 11:32:17 +01:00
virtual void adjust_computed_style(CSS::ComputedProperties&) override;
LibHTML: Implement basic <form> and <input> element support This patch adds "submit" inputs and default (text box) inputs, as well as form elements that can be submitted. Layout of input elements is implemented via a new LayoutWidget class that allows you to put an arbitrary GWidget in the layout tree. At the moment, the DOM node sets the initial size of the LayoutWidget, and then the positioning is done by the normal layout algorithm. We also now support submitting a <form method="GET">, which does a full replacing load with a URL based on the form's action + a query string built from the name/value of input elements within the submitted form. This is pretty neat! :^)
2019-11-25 21:21:55 +01:00
LibWeb: Make HTMLInputElement::TypeAttributeState an enum class
2022-03-26 17:59:58 +00:00
enum class TypeAttributeState {
LibWeb: Add <input> value sanitiztion algorithm The value sanitiztion algorithm is defined for some states of the type attribute, and sanitizes the value of the 'value' attribute
2022-02-17 23:05:46 +00:00
#define __ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE(_, state) state,
ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTES
#undef __ENUMERATE_HTML_INPUT_TYPE_ATTRIBUTE
};
LibWeb: Port HTMLInputElement interface from DeprecatedString to String
2023-09-03 16:27:10 +12:00
StringView type() const;
LibWeb: Use the cached HTMLInputElement type within associated getters
2022-03-16 07:46:17 -04:00
TypeAttributeState type_state() const { return m_type; }
LibWeb: Port HTMLInputElement interface from DeprecatedString to String
2023-09-03 16:27:10 +12:00
WebIDL::ExceptionOr<void> set_type(String const&);
LibWeb: Add the HTMLInputElement.type attribute This makes React react to change events on text <input> elements. :^)
2022-02-17 13:12:01 +01:00
LibWeb: Remove DOM element deprecated_get_attribute()
2024-01-16 19:04:45 +01:00
String default_value() const { return get_attribute_value(HTML::AttributeNames::value); }
LibWeb: Add basic support for <input type=checkbox> This is implemented entirely inside LibWeb, there is no GUI::CheckBox widget instantiated, unlike other input types. All input types should be moved to this new style of implementation.
2020-09-11 18:17:39 +02:00
LibWeb: Port the FormAssociatedElement value to UTF-16 This porting effort makes it pretty clear we will want a UTF-16-aware GenericLexer. But for now, we can actually make ASCII assumptions about what we are parsing, and act accordingly.
2025-07-26 12:19:56 -04:00
virtual Utf16String value() const override;
LibWeb/HTML: Implement and use "optional value" Corresponds to https://github.com/whatwg/html/commit/f3444c23ffba2eaba715db1c609253e5488fb530 Also import a test.
2025-07-08 11:28:10 +01:00
virtual Optional<String> optional_value() const override;
LibWeb: Port the FormAssociatedElement value to UTF-16 This porting effort makes it pretty clear we will want a UTF-16-aware GenericLexer. But for now, we can actually make ASCII assumptions about what we are parsing, and act accordingly.
2025-07-26 12:19:56 -04:00
WebIDL::ExceptionOr<void> set_value(Utf16String const&);
LibWeb: Start implementing <input type=text> using a shadow DOM Text <input> fields will now generate a basic shadow DOM and attach it to the input element. The shadow DOM contains a <div> with some inline style, and an always- editable text node inside it. Accessing the "value" attribute on such an input element will get/set the value from that text node. This is really cool, although not super stable since HTML editing is not super stable. But it's a start! :^)
2021-02-10 18:26:07 +01:00
LibWeb: Subclass FormAssociatedElement text selection methods These are only relevant to HTMLInputElement and HTMLTextArea elements.
2024-08-30 17:22:58 +01:00
// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-textarea/input-relevant-value
LibWeb: Port the FormAssociatedElement value to UTF-16 This porting effort makes it pretty clear we will want a UTF-16-aware GenericLexer. But for now, we can actually make ASCII assumptions about what we are parsing, and act accordingly.
2025-07-26 12:19:56 -04:00
virtual Utf16String relevant_value() override { return value(); }
WebIDL::ExceptionOr<void> set_relevant_value(Utf16String const& value) override { return set_value(value); }
LibWeb: Implement setRangeText for input and textarea elements This method replaces range of text in its respective element with a new string
2024-08-30 17:22:58 +01:00
virtual void set_dirty_value_flag(bool flag) override { m_dirty_value = flag; }
LibWeb: Subclass FormAssociatedElement text selection methods These are only relevant to HTMLInputElement and HTMLTextArea elements.
2024-08-30 17:22:58 +01:00
LibWeb: Implement CSS validity pseudo-classes
2025-02-02 20:41:23 +01:00
bool user_validity() const { return m_user_validity; }
void set_user_validity(bool flag) { m_user_validity = flag; }
LibWeb: Support committing changes to <input> elements We currently fire the change event on <input> elements when they lose focus. The spec allows for us to also fire the event when changes are "committed", so long as such an action makes sense for the input type. This patch detects when the return key is entered in an <input> element and uses that as the commit action for text-related types. If no change has occurred since the last commit, no change event is fired.
2023-11-30 12:54:30 -05:00
void commit_pending_changes();
LibWeb: Implement CSS validity pseudo-classes
2025-02-02 20:41:23 +01:00
bool has_uncommitted_changes() { return m_has_uncommitted_changes; }
LibWeb: Support committing changes to <input> elements We currently fire the change event on <input> elements when they lose focus. The spec allows for us to also fire the event when changes are "committed", so long as such an action makes sense for the input type. This patch detects when the return key is entered in an <input> element and uses that as the commit action for text-related types. If no change has occurred since the last commit, no change event is fired.
2023-11-30 12:54:30 -05:00
LibWeb: Hide input placeholder when input already has a value
2023-12-10 19:33:37 +01:00
String placeholder() const;
LibWeb: Remove ByteString usage in input element placeholder_value()
2024-03-15 17:40:40 +01:00
Optional<String> placeholder_value() const;
LibWeb: Support displaying HTMLInputElement placeholder values This adds support for parsing the ::placeholder pseudo-element and injecting an anonymous layout node with that element when the input element's data is empty.
2022-11-30 22:15:12 -05:00
LibWeb: Add basic support for <input type=checkbox> This is implemented entirely inside LibWeb, there is no GUI::CheckBox widget instantiated, unlike other input types. All input types should be moved to this new style of implementation.
2020-09-11 18:17:39 +02:00
bool checked() const { return m_checked; }
LibWeb: Set dirty checkedness flag when setting `checked` IDL attribute This matches the behavior of other browsers, which always set the dirty checkedness flag when setting checkedness, except when setting the `checked` content attribute.
2025-01-05 20:50:09 +00:00
void set_checked(bool);
LibWeb: Implement <input type=submit> without using LibGUI Following in the footsteps of <input type=checkbox>, this patch adds LayoutButton which implements a basic push button using LibGfx styling primitives.
2020-09-12 17:56:11 +02:00
LibWeb: Ensure that radio group is updated when radio is checked from JS Fixes test 56 in Acid3. Farewell, radio eyes, you will be missed. :^(
2022-03-15 01:13:05 +00:00
bool checked_binding() const { return checked(); }
void set_checked_binding(bool);
Everywhere: Remove needless trailing semi-colons after functions This is a new option in clang-format-16.
2023-07-07 22:48:11 -04:00
bool indeterminate() const { return m_indeterminate; }
LibWeb: Implement indeterminate IDL attribute in HTMLInputElement
2023-03-20 04:34:43 -04:00
void set_indeterminate(bool);
LibWeb: Don't place cursor on certain <input> elements For example, button inputs shouldn't have a cursor displayed in their text since they're not editable, and are not meant to be editable. Fixes #4140 Co-authored-by: Sam Atkins <sam@ladybird.org>
2025-05-16 09:22:38 +05:30
bool can_have_text_editing_cursor() const;
LibWeb: Implement the `HTMLInputElement.list` attribute This returns the `HTMLDataListElement` pointed to by the `list` content attribute.
2025-03-03 15:23:48 +00:00
GC::Ptr<HTMLDataListElement const> list() const;
LibWeb: Do not issue `change` event for every update of color input Per spec, the change event shall only be issued once the change is finally committed by the user, IE by closing the color picker window.
2024-03-02 18:06:44 +01:00
void did_pick_color(Optional<Color> picked_color, ColorPickerUpdateState state);
LibWeb+LibWebView+WebContent: Implement more <input type=file> behavior We had previous implemented some plumbing for file input elements in commit 636602a54e55945f7394805975a69dc40934331c. This implements the return path for chromes to inform WebContent of the file(s) the user selected. This patch includes a dummy implementation for headless-browser to enable testing.
2024-02-25 13:02:47 -05:00
LibWeb: Support appending files to <input type=file> This isn't exposed to the Web, but WebDriver requires this feature.
2024-10-10 20:10:37 -04:00
enum class MultipleHandling {
Replace,
Append,
};
void did_select_files(Span<SelectedFile> selected_files, MultipleHandling = MultipleHandling::Replace);
LibWeb+LibWebView+WebContent: Add support for <input type="color"> This commit introduces 3 things: - Support for the color type in HTMLInputElement itself - A mechanism for handling non event loop blocking dialogs in Page - The associated plumbing up to ViewImplementation Frontends may add support for the color picker with the ViewImplementation.on_request_color_picker function
2023-09-04 11:32:40 +02:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<FileAPI::FileList> files();
void set_files(GC::Ptr<FileAPI::FileList>);
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-03 23:39:53 -06:00
Ladybird+LibWeb+WebContent: Parse the <input type=file> accept attribute This parses the accept attribute value for file input types and passes it along to the browser chromes.
2024-03-14 12:26:00 -04:00
FileFilter parse_accept_attribute() const;
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-03 23:39:53 -06:00
// NOTE: User interaction
// https://html.spec.whatwg.org/multipage/input.html#update-the-file-selection
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
void update_the_file_selection(GC::Ref<FileAPI::FileList>);
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-03 23:39:53 -06:00
LibWeb: Add input and textarea minlength and maxlength support
2024-03-01 08:49:04 +01:00
WebIDL::Long max_length() const;
WebIDL::ExceptionOr<void> set_max_length(WebIDL::Long);
WebIDL::Long min_length() const;
WebIDL::ExceptionOr<void> set_min_length(WebIDL::Long);
LibWeb: Limit `HTMLInputElement.size` to allowed values Attempting to set `HTMLInputElement.size` to 0 via IDL now throws an IndexSizeError DOMException. Attempting to set it to a value larger than 2147483647 results in it being set to the default value.
2024-11-28 14:33:53 +00:00
WebIDL::UnsignedLong size() const;
WebIDL::ExceptionOr<void> set_size(WebIDL::UnsignedLong value);
LibWeb: Add support for the input size attribute
2023-11-24 17:37:53 +01:00
LibWeb: Implement the `HTMLInputElement.height` attribute This allows the height of an image button input to be set and queried.
2024-11-29 17:56:24 +00:00
WebIDL::UnsignedLong height() const;
WebIDL::ExceptionOr<void> set_height(WebIDL::UnsignedLong value);
LibWeb: Implement the `HTMLInputElement.width` attribute This allows the width of an image button input to be set and queried.
2024-11-29 17:45:07 +00:00
WebIDL::UnsignedLong width() const;
WebIDL::ExceptionOr<void> set_width(WebIDL::UnsignedLong value);
LibWeb: Implement HTMLInputElement's selected coordinates When an <input type=image> button is clicked, we now send the (x,y) coordinates of the click event (relative to the image) along with the form submission data. Regarding the text test, we can currently only test this feature with dialogs. The headless-browser test infrastructure cannot yet handle the resulting navigation that would occur if we were to test with normal form submission.
2024-02-19 00:21:27 -05:00
struct SelectedCoordinate {
LibWeb: Store the input image button's selected coordinates as integers The spec has prose which states, e.g., "The x-component must be a valid integer".
2024-02-19 07:44:11 -05:00
int x { 0 };
int y { 0 };
LibWeb: Implement HTMLInputElement's selected coordinates When an <input type=image> button is clicked, we now send the (x,y) coordinates of the click event (relative to the image) along with the form submission data. Regarding the text test, we can currently only test this feature with dialogs. The headless-browser test infrastructure cannot yet handle the resulting navigation that would occur if we were to test with normal form submission.
2024-02-19 00:21:27 -05:00
};
SelectedCoordinate selected_coordinate() const { return m_selected_coordinate; }
LibWeb: Add input element valueAsDate property
2023-12-15 18:23:29 +01:00
JS::Object* value_as_date() const;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<void> set_value_as_date(Optional<GC::Root<JS::Object>> const&);
LibWeb: Add input element valueAsDate property
2023-12-15 18:23:29 +01:00
double value_as_number() const;
LibWeb: Add input element valueAsNumber
2023-10-04 22:40:31 +02:00
WebIDL::ExceptionOr<void> set_value_as_number(double value);
LibWeb: Use WebIDL types where possible instead of C types
2024-02-26 18:54:36 +01:00
WebIDL::ExceptionOr<void> step_up(WebIDL::Long n = 1);
WebIDL::ExceptionOr<void> step_down(WebIDL::Long n = 1);
LibWeb: Add input stepUp and stepDown functions
2023-12-07 19:35:45 +01:00
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-03 23:39:53 -06:00
WebIDL::ExceptionOr<void> show_picker();
LibWeb: Make any HTMLInputElement with type != hidden focusable From the HTML spec: Modulo platform conventions, it is suggested that the following elements should be considered as focusable areas and be sequentially focusable: ... - input elements whose type attribute are not in the Hidden state ...
2022-03-26 18:02:41 +00:00
// ^EventTarget
// https://html.spec.whatwg.org/multipage/interaction.html#the-tabindex-attribute:the-input-element
LibWeb: Do not allow focusing "Actually Disabled" elements
2024-11-02 19:17:20 +01:00
// https://html.spec.whatwg.org/multipage/interaction.html#focusable-area
// https://html.spec.whatwg.org/multipage/semantics-other.html#concept-element-disabled
virtual bool is_focusable() const override;
LibWeb: Make HTMLInputElement move cursor into text node when focused This mechanism feels rather awkward, but it's better than nothing.
2022-02-06 19:27:10 +01:00
LibWeb: Add form associated element categories
2022-03-01 21:03:30 +00:00
// ^FormAssociatedElement
// https://html.spec.whatwg.org/multipage/forms.html#category-listed
virtual bool is_listed() const override { return true; }
// https://html.spec.whatwg.org/multipage/forms.html#category-submit
virtual bool is_submittable() const override { return true; }
// https://html.spec.whatwg.org/multipage/forms.html#category-reset
virtual bool is_resettable() const override { return true; }
// https://html.spec.whatwg.org/multipage/forms.html#category-autocapitalize
LibWeb: Update `is_autocapitalize_inheriting` method name with spec This was changed when the autocorrect attribute was introduced: https://github.com/whatwg/html/commit/7bab05a
2025-05-26 16:21:29 +12:00
virtual bool is_autocapitalize_and_autocorrect_inheriting() const override { return true; }
LibWeb: Add form associated element categories
2022-03-01 21:03:30 +00:00
LibWeb: Fix up constructing the form entry list In particular: - Don't include none submitter buttons. - Use type_state() instead type() to avoid direct string comparisons - Support the hidden _charset_ input - Get form associated element's value directly instead of via the value attribute - Split line break normalization into a separate function so that it can also be used by form submission.
2023-06-18 15:08:15 +01:00
// https://html.spec.whatwg.org/multipage/forms.html#concept-button
virtual bool is_button() const override;
// https://html.spec.whatwg.org/multipage/forms.html#concept-submit-button
virtual bool is_submit_button() const override;
LibWeb: Add method `HTMLInputElement::is_single_line()`
2024-07-07 11:05:13 -05:00
bool is_single_line() const;
LibWeb: Implement reset algorithm for HTMLInputElement
2022-12-22 19:33:37 -05:00
virtual void reset_algorithm() override;
LibWeb: Implement the form associated element clear algorithm This is a method defined in the WebDriver spec, but requires access to a bunch of private fields in these classes, so this is implemented in the same manner as the reset algorithm.
2024-10-11 10:38:43 -04:00
virtual void clear_algorithm() override;
LibWeb: Implement reset algorithm for HTMLInputElement
2022-12-22 19:33:37 -05:00
LibWeb: Remove inheritance of FormAssociatedElement from HTMLElement HTMLObjectElement will need to be both a FormAssociatedElement and a BrowsingContextContainer. Currently, both of these classes inherit from HTMLElement. This can work in C++, but is generally frowned upon, and doesn't play particularly well with the rest of LibWeb. Instead, we can essentially revert commit 3bb5c62 to remove HTMLElement from FormAssociatedElement's hierarchy. This means that objects such as HTMLObjectElement individually inherit from FormAssociatedElement and HTMLElement now. Some caveats are: * FormAssociatedElement still needs to know when the HTMLElement is inserted into and removed from the DOM. This hook is automatically injected via a macro now, while still allowing classes like HTMLInputElement to also know when the element is inserted. * Casting from a DOM::Element to a FormAssociatedElement is now a sideways cast, rather than directly following an inheritance chain. This means static_cast cannot be used here; but we can safely use dynamic_cast since the only 2 instances of this already use RTTI to verify the cast.
2022-03-23 18:55:54 -04:00
virtual void form_associated_element_was_inserted() override;
LibWeb/HTML: Sanitize email input with multiple attribute This implements the missing part of the value sanitization algorithm for email inputs with the multiple attribute.
2025-07-22 00:58:28 +02:00
virtual void form_associated_element_attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
LibWeb: Remove inheritance of FormAssociatedElement from HTMLElement HTMLObjectElement will need to be both a FormAssociatedElement and a BrowsingContextContainer. Currently, both of these classes inherit from HTMLElement. This can work in C++, but is generally frowned upon, and doesn't play particularly well with the rest of LibWeb. Instead, we can essentially revert commit 3bb5c62 to remove HTMLElement from FormAssociatedElement's hierarchy. This means that objects such as HTMLObjectElement individually inherit from FormAssociatedElement and HTMLElement now. Some caveats are: * FormAssociatedElement still needs to know when the HTMLElement is inserted into and removed from the DOM. This hook is automatically injected via a macro now, while still allowing classes like HTMLInputElement to also know when the element is inserted. * Casting from a DOM::Element to a FormAssociatedElement is now a sideways cast, rather than directly following an inheritance chain. This means static_cast cannot be used here; but we can safely use dynamic_cast since the only 2 instances of this already use RTTI to verify the cast.
2022-03-23 18:55:54 -04:00
LibWeb: Make node cloning methods const
2025-01-11 17:37:08 +00:00
virtual WebIDL::ExceptionOr<void> cloned(Node&, bool) const override;
LibWeb: Implement cloning steps for `HTMLInputElement`
2024-08-21 12:19:37 +01:00
LibWeb: Add form associated element categories
2022-03-01 21:03:30 +00:00
// ^HTMLElement
// https://html.spec.whatwg.org/multipage/forms.html#category-label
virtual bool is_labelable() const override { return type_state() != TypeAttributeState::Hidden; }
LibWeb: Move ARIA-related code into the Web::ARIA namespace ARIA has its own spec and is not part of the DOM spec, which is what the Web::DOM namespace is for (https://www.w3.org/TR/wai-aria-1.2/). This allows us to stay closer to the spec with function names and don't have to add the word "ARIA" to identifiers constantly - the namespace now provides that clarity.
2023-01-28 22:23:16 +00:00
virtual Optional<ARIA::Role> default_role() const override;
LibWeb: Add Support for the ARIA Element Properties Element now supports getting and setting ARIA properties from JS and HTML.
2022-11-28 17:58:13 -06:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<Element> placeholder_element() { return m_placeholder_element; }
GC::Ptr<Element const> placeholder_element() const { return m_placeholder_element; }
LibWeb: Make input element placeholders look better We now create a flex container inside the input element's UA shadow tree and add the placeholder and non-placeholder text as flex items (wrapped in elements whose style we can manipulate). This fixes the visual glitch where the placeholder would appear below the bounding box of the input element. It also allows us to align the text vertically inside the input element (like we're supposed to). In order to achieve this, I had to make two small architectural changes to layout tree building: - Elements can now report that they represent a given pseudo element. This allows us to instantiate the ::placeholder pseudo element as an actual DOM element inside the input element's UA shadow tree. - We no longer create a separate layout node for the shadow root itself. Instead, children of the shadow root are treated as if they were children of the DOM element itself for the purpose of layout tree building.
2023-05-25 12:34:54 +02:00
LibWeb: Make EventTarget::activation_behavior a virtual function (Instead of using an AK::Function on EventTarget). This shaves 48 bytes off of every EventTarget instance.
2023-11-18 10:48:09 +01:00
virtual bool has_activation_behavior() const override;
virtual void activation_behavior(DOM::Event const&) override;
LibWeb: Fire a change event on input elements in the focus update steps This ensures the change event is received before the blur event.
2023-12-03 08:24:16 -05:00
bool has_input_activation_behavior() const;
bool change_event_applies() const;
LibWeb: Add input element valueAsDate property
2023-12-15 18:23:29 +01:00
bool value_as_date_applies() const;
LibWeb: Move logic to check if valueAsNumber applies to its own function
2023-12-07 19:31:42 +01:00
bool value_as_number_applies() const;
LibWeb: Add input stepUp and stepDown functions
2023-12-07 19:35:45 +01:00
bool step_applies() const;
bool step_up_or_down_applies() const;
LibWeb: Implement input/textarea selection APIs For both types of elements, `.selectionStart`, `.selectionEnd`, `.selectionDirection`, `.setSelectionRange()`, `.select()` and the `select` event are now implemented.
2024-08-22 15:20:24 +02:00
bool select_applies() const;
HTML: Partially implement HTMLInputElement's selection{Start,End} Now that the implementation is in FormAssociatedElement, the implementation in HTMLInputElement is effectively just a passthrough, with some minor differences to handle small behavioural quirks between the two (such as the difference in nullability of types).
2024-07-28 16:41:45 +12:00
bool selection_or_range_applies() const;
LibWeb: Follow spec steps to set the selectionDirection attribute value
2024-10-04 12:12:39 +01:00
bool selection_direction_applies() const;
LibWeb: Implement the `HTMLInputElement` pattern attribute
2025-02-27 10:13:52 +00:00
bool pattern_applies() const;
bool multiple_applies() const;
LibWeb: Implement :required/:optional pseudo-classes
2025-04-30 10:23:46 +10:00
bool required_applies() const;
LibWeb: Implement the :default pseudo-class
2025-05-24 15:24:38 +10:00
bool checked_applies() const;
LibWeb/HTML: Select html input elements with selectable text only select input elements that select applies to and has a selectable text.
2024-09-18 15:34:40 +01:00
bool has_selectable_text() const;
HTML: Partially implement HTMLInputElement's selection{Start,End} Now that the implementation is in FormAssociatedElement, the implementation in HTMLInputElement is effectively just a passthrough, with some minor differences to handle small behavioural quirks between the two (such as the difference in nullability of types).
2024-07-28 16:41:45 +12:00
LibWeb: Support :open for file and color `<input>` elements
2025-01-31 15:34:34 +00:00
bool supports_a_picker() const;
bool is_open() const { return m_is_open; }
void set_is_open(bool);
LibWeb: Make input type state change handling specification compliant This change ensures that the value sanitization algorithm is run and the text cursor is set to the correct position when the type attribute of an input is changed.
2024-09-10 09:24:00 +01:00
static bool selection_or_range_applies_for_type_state(TypeAttributeState);
LibWeb: Follow spec steps to set the selectionDirection attribute value
2024-10-04 12:12:39 +01:00
Optional<String> selection_direction_binding() { return selection_direction(); }
LibWeb: Delete EditableTextNodeOwner It's no longer needed after FormAssociatedTextControlElement became responsible for managing input events for text controls.
2024-11-06 16:46:50 +01:00
// ^FormAssociatedTextControlElement
virtual void did_edit_text_node() override;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
virtual GC::Ptr<DOM::Text> form_associated_element_to_text_node() override { return m_text_node; }
LibWeb: Propagate input/textarea selection update to document selection Calling `.setSelectionRange()` or `.select()` now updates the document selection as well, visualizing the text selection.
2024-08-26 14:08:40 +02:00
LibWeb: Implement “suffering from overflow/underflow” for inputs This change implements the requirements for the “suffering from an overflow” and “suffering from an underflow” algorithms for HTMLInputElement constraint validation.
2025-03-07 16:44:29 +09:00
// https://html.spec.whatwg.org/multipage/input.html#has-a-periodic-domain/
bool has_periodic_domain() const { return type_state() == HTMLInputElement::TypeAttributeState::Time; }
// https://html.spec.whatwg.org/multipage/input.html#has-a-reversed-range
bool has_reversed_range() const;
LibWeb: Implement CSS validity pseudo-classes
2025-02-02 20:41:23 +01:00
// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#definitions
virtual bool suffering_from_being_missing() const override;
virtual bool suffering_from_a_type_mismatch() const override;
virtual bool suffering_from_a_pattern_mismatch() const override;
virtual bool suffering_from_an_underflow() const override;
virtual bool suffering_from_an_overflow() const override;
virtual bool suffering_from_a_step_mismatch() const override;
virtual bool suffering_from_bad_input() const override;
LibWeb/HTML: Correctly compute whether element is mutable This adapts the implementation of `is_mutable` to align more closely with the spec. Specifically, it is now also taken into account whether the element is enabled.
2025-08-10 00:29:35 +02:00
virtual bool is_mutable() const override;
LibWeb: Add HTMLElement::uses_button_layout() This suits the spec a bit better, and exposes the fact that we were allowing `::ImageButton` to use the button layout although it is never specified that it should do so. Tests were rebaselined for this.
2025-08-15 09:42:52 +02:00
virtual bool uses_button_layout() const override;
LibWeb/HTML: Correctly compute whether element is mutable This adapts the implementation of `is_mutable` to align more closely with the spec. Specifically, it is now also taken into account whether the element is enabled.
2025-08-10 00:29:35 +02:00
LibWeb: Add basic support for <input type=checkbox> This is implemented entirely inside LibWeb, there is no GUI::CheckBox widget instantiated, unlike other input types. All input types should be moved to this new style of implementation.
2020-09-11 18:17:39 +02:00
private:
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
HTMLInputElement(DOM::Document&, DOM::QualifiedName);
LibWeb: Make input type state change handling specification compliant This change ensures that the value sanitization algorithm is run and the text cursor is set to the correct position when the type attribute of an input is changed.
2024-09-10 09:24:00 +01:00
void type_attribute_changed(TypeAttributeState old_state, TypeAttributeState new_state);
LibWeb: Avoid many style invalidations on DOM attribute mutation Many times, attribute mutation doesn't necessitate a full style invalidation on the element. However, the conditions are pretty elaborate, so this first version has a lot of false positives. We only need to invalidate style when any of these things apply: 1. The change may affect the match state of a selector somewhere. 2. The change may affect presentational hints applied to the element. For (1) in this first version, we have a fixed list of attribute names that may affect selectors. We also collect all names referenced by attribute selectors anywhere in the document. For (2), we add a new Element::is_presentational_hint() virtual that tells us whether a given attribute name is a presentational hint. This drastically reduces style work on many websites. As an example, https://cnn.com/ is once again browseable.
2024-12-23 17:51:10 +01:00
virtual bool is_presentational_hint(FlyString const&) const override;
LibWeb: Split StyleComputer work into two phases with separate outputs Before this change, StyleComputer would essentially take a DOM element, find all the CSS rules that apply to it, and resolve the computed value for each CSS property for that element. This worked great, but it meant we had to do all the work of selector matching and cascading every time. To enable new optimizations, this change introduces a break in the middle of this process where we've produced a "CascadedProperties". This object contains the result of the cascade, before we've begun turning cascaded values into computed values. The cascaded properties are now stored with each element, which will later allow us to do partial updates without re-running the full StyleComputer machine. This will be particularly valuable for re-implementing CSS inheritance, which is extremely heavy today. Note that CSS animations and CSS transitions operate entirely on the computed values, even though the cascade order would have you believe they happen earlier. I'm not confident we have the right architecture for this, but that's a separate issue.
2024-12-12 10:06:29 +01:00
virtual void apply_presentational_hints(GC::Ref<CSS::CascadedProperties>) const override;
LibWeb: Map embedded content element attributes to dimension properties
2024-10-01 17:26:01 +01:00
LibWeb: Add fast_is<T>() for various types stood out in a profile
2023-03-10 21:16:18 +01:00
// ^DOM::Node
virtual bool is_html_input_element() const final { return true; }
LibWeb: Make HTMLInputElement move cursor into text node when focused This mechanism feels rather awkward, but it's better than nothing.
2022-02-06 19:27:10 +01:00
// ^DOM::EventTarget
LibWeb: Adjust change event timing for input elements
2023-05-29 18:41:32 +02:00
virtual void did_lose_focus() override;
LibWeb: Make HTMLInputElement move cursor into text node when focused This mechanism feels rather awkward, but it's better than nothing.
2022-02-06 19:27:10 +01:00
virtual void did_receive_focus() override;
LibWeb: Refactor all LabelableNode subclasses + input event handling :^) This commit is messy due to the Paintable and Layout classes being tangled together. The RadioButton, CheckBox and ButtonBox classes are now subclasses of FormAssociatedLabelableNode. This subclass separates these layout nodes from LabelableNode, which is also the superclass of non-form associated labelable nodes (Progress). ButtonPaintable, CheckBoxPaintable and RadioButtonPaintable no longer call events on DOM nodes directly from their mouse event handlers; instead, all the functionality is now directly in EventHandler, which dispatches the related events. handle_mousedown and related methods return a bool indicating whether the event handling should proceed. Paintable classes can now return an alternative DOM::Node which should be the target of the mouse event. Labels use this to indicate that the labeled control should be the target of the mouse events. HTMLInputElement put its activation behavior on run_activation_behavior, which wasn't actually called anywhere and had to be manually called by other places. We now use activation_behavior which is used by EventDispatcher. This commit also brings HTMLInputElement closer to spec by removing the did_foo functions that did ad-hoc event dispatching and unifies the behavior under run_input_activation_behavior.
2022-03-14 23:05:55 +00:00
virtual void legacy_pre_activation_behavior() override;
virtual void legacy_cancelled_activation_behavior() override;
virtual void legacy_cancelled_activation_behavior_was_not_called() override;
LibWeb: Make HTMLInputElement move cursor into text node when focused This mechanism feels rather awkward, but it's better than nothing.
2022-02-06 19:27:10 +01:00
LibWeb: Implement HTMLOrSVGElement.tabIndex
2022-11-05 03:58:14 +00:00
// ^DOM::Element
virtual i32 default_tab_index_value() const override;
LibWeb: Generalize support for dimension attributes Rather than each element which supports dimension attributes needing to implement parsing the attributes and setting the appropriate style, we can generalize this functionality. This will also make each element more closely resemble the spec text, as we will be effectively declaring, for example, "The img element supports dimension attributes" in code.
2024-04-10 21:44:11 -04:00
// https://html.spec.whatwg.org/multipage/input.html#image-button-state-(type=image):dimension-attributes
virtual bool supports_dimension_attributes() const override { return type_state() == TypeAttributeState::ImageButton; }
LibWeb: Implement HTMLOrSVGElement.tabIndex
2022-11-05 03:58:14 +00:00
LibWeb: Begin implementing the HTMLInputElement 'image' type state This implements enough to represent <input type=image> with its loaded source image (or fallback to its alt text, if applicable). This does not implement acquring coordinates from user-activated click events on the image.
2024-02-18 21:12:14 -05:00
// ^Layout::ImageProvider
virtual bool is_image_available() const override;
virtual Optional<CSSPixels> intrinsic_width() const override;
virtual Optional<CSSPixels> intrinsic_height() const override;
virtual Optional<CSSPixelFraction> intrinsic_aspect_ratio() const override;
LibWeb: Use intrinsic size for current_image_bitmap Currently, ImageProvider::current_image_bitmap takes a Gfx::IntSize argument which determines the size of the returned bitmap. The default value of this argument is 0x0 which causes the function to return nullptr. This behavior is evidently unintuitive enough that it has lead to incorrect usage in multiple places. For example, the 2D canvas drawImage method will never actually draw anything because it calls current_image_bitmap with no arguments. And the naturalWidth and naturalHeight of an image will always return 0 (even after the image has loaded) for the same reason. To correct this and hopefully avoid similar issues in the future, ImageProvider::current_image_bitmap will be renamed to current_image_bitmap_sized, and the default value for the size argument will be removed. For consistency, a similar change will be made to SVGImageElement::default_image_bitmap. The existing current_image_bitmap function will no longer take a size argument. Instead it will always return a bitmap of the image's intrinsic size. This seems to be what most existing callers had already assumed was the function's behavior.
2025-08-28 11:21:46 -04:00
virtual RefPtr<Gfx::ImmutableBitmap> current_image_bitmap_sized(Gfx::IntSize) const override;
LibWeb: Begin implementing the HTMLInputElement 'image' type state This implements enough to represent <input type=image> with its loaded source image (or fallback to its alt text, if applicable). This does not implement acquring coordinates from user-activated click events on the image.
2024-02-18 21:12:14 -05:00
virtual void set_visible_in_viewport(bool) override;
LibWeb: Allow ImageProvider to not have a corresponding DOM node This is prep work for CSS content:image.
2025-07-26 14:46:23 +02:00
virtual GC::Ptr<DOM::Element const> to_html_element() const override { return *this; }
LibWeb: Begin implementing the HTMLInputElement 'image' type state This implements enough to represent <input type=image> with its loaded source image (or fallback to its alt text, if applicable). This does not implement acquring coordinates from user-activated click events on the image.
2024-02-18 21:12:14 -05:00
LibJS: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405
2023-08-07 08:41:28 +02:00
virtual void initialize(JS::Realm&) override;
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
virtual void visit_edges(Cell::Visitor&) override;
LibWeb: Implement “convert a string to a number” for type=time inputs
2025-03-04 20:19:45 +09:00
Optional<double> convert_time_string_to_number(StringView input) const;
LibWeb: Add basis of the convert number to string algorithm functions
2023-12-07 19:29:32 +01:00
Optional<double> convert_string_to_number(StringView input) const;
LibWeb: Port the FormAssociatedElement value to UTF-16 This porting effort makes it pretty clear we will want a UTF-16-aware GenericLexer. But for now, we can actually make ASCII assumptions about what we are parsing, and act accordingly.
2025-07-26 12:19:56 -04:00
Optional<double> convert_string_to_number(Utf16String const& input) const;
Utf16String convert_number_to_string(double input) const;
LibWeb: Add basis of the convert number to string algorithm functions
2023-12-07 19:29:32 +01:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
WebIDL::ExceptionOr<GC::Ptr<JS::Date>> convert_string_to_date(StringView input) const;
LibWeb: Port the FormAssociatedElement value to UTF-16 This porting effort makes it pretty clear we will want a UTF-16-aware GenericLexer. But for now, we can actually make ASCII assumptions about what we are parsing, and act accordingly.
2025-07-26 12:19:56 -04:00
WebIDL::ExceptionOr<GC::Ptr<JS::Date>> convert_string_to_date(Utf16String const& input) const;
Utf16String convert_date_to_string(GC::Ref<JS::Date> input) const;
LibWeb: Add input element valueAsDate property
2023-12-15 18:23:29 +01:00
LibWeb: Add input stepUp and stepDown functions
2023-12-07 19:35:45 +01:00
Optional<double> min() const;
Optional<double> max() const;
double default_step() const;
double step_scale_factor() const;
Optional<double> allowed_value_step() const;
double step_base() const;
LibWeb: Use WebIDL types where possible instead of C types
2024-02-26 18:54:36 +01:00
WebIDL::ExceptionOr<void> step_up_or_down(bool is_down, WebIDL::Long n);
LibWeb: Add input stepUp and stepDown functions
2023-12-07 19:35:45 +01:00
LibWeb: Cache HTMLInputElement's parsed type attribute when it changes This will let us avoid parsing the type each time type() or type_state() are invoked.
2022-03-16 07:44:21 -04:00
static TypeAttributeState parse_type_attribute(StringView);
LibWeb: Port the FormAssociatedElement value to UTF-16 This porting effort makes it pretty clear we will want a UTF-16-aware GenericLexer. But for now, we can actually make ASCII assumptions about what we are parsing, and act accordingly.
2025-07-26 12:19:56 -04:00
Utf16String button_label() const;
LibWeb: Start implementing <input type=text> using a shadow DOM Text <input> fields will now generate a basic shadow DOM and attach it to the input element. The shadow DOM contains a <div> with some inline style, and an always- editable text node inside it. Accessing the "value" attribute on such an input element will get/set the value from that text node. This is really cool, although not super stable since HTML editing is not super stable. But it's a start! :^)
2021-02-10 18:26:07 +01:00
void create_shadow_tree_if_needed();
LibWeb: Move code to update HTMLInputElement's shadow tree to a helper We currently copy-paste a series of if statements to selectively update the shadow tree elements for some <input> types. This will soon become longer as more shadow trees are implemented for other types. This patch just moves those checks to a single location to make adding more shadow trees easier.
2024-02-25 10:43:17 -05:00
void update_shadow_tree();
LibWeb: Create BlockContainer layout node for `<input type="button">` ...and shadow tree with TextNode for "value" attribute is created. This means InlineFormattingContext is used, and button's text now respects CSS text-decoration properties and unicode-ranges.
2024-06-13 20:04:41 +03:00
void create_button_input_shadow_tree();
LibWeb/HTMLInputElement: Move text input shadow tree into a function
2023-10-13 21:06:34 +02:00
void create_text_input_shadow_tree();
LibWeb/HTMLInputElement: Improve appearance of color picker Instead of a plain ButtonBox, it now appears as a color well styled after the buttons.
2023-10-14 12:00:40 +02:00
void create_color_input_shadow_tree();
LibWeb: Create a shadow tree for <input type=file> elements This creates a button to prompt users to select a file, and a label to show information about the selected file(s). Clicking either shadow element will activate the input element.
2024-02-25 10:54:37 -05:00
void create_file_input_shadow_tree();
LibWeb: Add basic input range rendering
2023-12-11 18:00:06 +01:00
void create_range_input_shadow_tree();
LibWeb: Respect the trusted state of input events when submitting forms This involves passing the UserNavigationInvolvement from each form associated element that triggers a submit through to the methods that perform the actual navigation. While here, refactor HTMLFormElement to use the new Bindings::NavigationHistoryBehavior enum.
2024-01-18 12:58:22 -07:00
WebIDL::ExceptionOr<void> run_input_activation_behavior(DOM::Event const&);
LibWeb: Refactor all LabelableNode subclasses + input event handling :^) This commit is messy due to the Paintable and Layout classes being tangled together. The RadioButton, CheckBox and ButtonBox classes are now subclasses of FormAssociatedLabelableNode. This subclass separates these layout nodes from LabelableNode, which is also the superclass of non-form associated labelable nodes (Progress). ButtonPaintable, CheckBoxPaintable and RadioButtonPaintable no longer call events on DOM nodes directly from their mouse event handlers; instead, all the functionality is now directly in EventHandler, which dispatches the related events. handle_mousedown and related methods return a bool indicating whether the event handling should proceed. Paintable classes can now return an alternative DOM::Node which should be the target of the mouse event. Labels use this to indicate that the labeled control should be the target of the mouse events. HTMLInputElement put its activation behavior on run_activation_behavior, which wasn't actually called anywhere and had to be manually called by other places. We now use activation_behavior which is used by EventDispatcher. This commit also brings HTMLInputElement closer to spec by removing the did_foo functions that did ad-hoc event dispatching and unifies the behavior under run_input_activation_behavior.
2022-03-14 23:05:55 +00:00
void set_checked_within_group();
LibWeb: Start implementing <input type=text> using a shadow DOM Text <input> fields will now generate a basic shadow DOM and attach it to the input element. The shadow DOM contains a <div> with some inline style, and an always- editable text node inside it. Accessing the "value" attribute on such an input element will get/set the value from that text node. This is really cool, although not super stable since HTML editing is not super stable. But it's a start! :^)
2021-02-10 18:26:07 +01:00
LibWeb: Add input and textarea minlength and maxlength support
2024-03-01 08:49:04 +01:00
void handle_maxlength_attribute();
LibWeb: Handle <input> element type changing to the image button state The spec has special steps specific to the image button state to load the element's image URL.
2024-04-04 12:56:37 -04:00
WebIDL::ExceptionOr<void> handle_src_attribute(String const& value);
LibWeb: Support readonly attribute for input elements
2023-09-03 00:07:58 +12:00
LibWeb: Deduplicate the firing of input events in HTMLInputElement Input elements without a defined user-interaction behavior need to fire an input event when the user changes the element's value in some way. This change moves the code to do this into its own function and adds some spec text to explain what is being done.
2024-05-18 05:45:13 +01:00
void user_interaction_did_change_input_value();
LibWeb: Add <input> value sanitiztion algorithm The value sanitiztion algorithm is defined for some states of the type attribute, and sanitizes the value of the 'value' attribute
2022-02-17 23:05:46 +00:00
// https://html.spec.whatwg.org/multipage/input.html#value-sanitization-algorithm
LibWeb: Port the FormAssociatedElement value to UTF-16 This porting effort makes it pretty clear we will want a UTF-16-aware GenericLexer. But for now, we can actually make ASCII assumptions about what we are parsing, and act accordingly.
2025-07-26 12:19:56 -04:00
Utf16String value_sanitization_algorithm(Utf16String const&) const;
LibWeb: Add <input> value sanitiztion algorithm The value sanitiztion algorithm is defined for some states of the type attribute, and sanitizes the value of the 'value' attribute
2022-02-17 23:05:46 +00:00
LibWeb: Fully implement the HTMLInputElement `value` setter and getter The setter was missing an implementation for the default and default/on value attribute modes. This patch adds a method to get the current value attribute mode, and implements the value setter and getter based on that mode according to the spec.
2024-02-17 16:27:41 -05:00
enum class ValueAttributeMode {
Value,
Default,
DefaultOn,
Filename,
};
LibWeb: Make input type state change handling specification compliant This change ensures that the value sanitization algorithm is run and the text cursor is set to the correct position when the type attribute of an input is changed.
2024-09-10 09:24:00 +01:00
static ValueAttributeMode value_attribute_mode_for_type_state(TypeAttributeState);
LibWeb: Fully implement the HTMLInputElement `value` setter and getter The setter was missing an implementation for the default and default/on value attribute modes. This patch adds a method to get the current value attribute mode, and implements the value setter and getter based on that mode according to the spec.
2024-02-17 16:27:41 -05:00
ValueAttributeMode value_attribute_mode() const;
LibWeb: Make input element placeholders look better We now create a flex container inside the input element's UA shadow tree and add the placeholder and non-placeholder text as flex items (wrapped in elements whose style we can manipulate). This fixes the visual glitch where the placeholder would appear below the bounding box of the input element. It also allows us to align the text vertically inside the input element (like we're supposed to). In order to achieve this, I had to make two small architectural changes to layout tree building: - Elements can now report that they represent a given pseudo element. This allows us to instantiate the ::placeholder pseudo element as an actual DOM element inside the input element's UA shadow tree. - We no longer create a separate layout node for the shadow root itself. Instead, children of the shadow root are treated as if they were children of the DOM element itself for the purpose of layout tree building.
2023-05-25 12:34:54 +02:00
void update_placeholder_visibility();
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<DOM::Element> m_placeholder_element;
GC::Ptr<DOM::Text> m_placeholder_text_node;
LibWeb: Make input element placeholders look better We now create a flex container inside the input element's UA shadow tree and add the placeholder and non-placeholder text as flex items (wrapped in elements whose style we can manipulate). This fixes the visual glitch where the placeholder would appear below the bounding box of the input element. It also allows us to align the text vertically inside the input element (like we're supposed to). In order to achieve this, I had to make two small architectural changes to layout tree building: - Elements can now report that they represent a given pseudo element. This allows us to instantiate the ::placeholder pseudo element as an actual DOM element inside the input element's UA shadow tree. - We no longer create a separate layout node for the shadow root itself. Instead, children of the shadow root are treated as if they were children of the DOM element itself for the purpose of layout tree building.
2023-05-25 12:34:54 +02:00
LibWeb: Provide default text for Reset and Submit buttons
2025-01-07 00:30:02 +01:00
void update_button_input_shadow_tree();
LibWeb: Recreate the <input> shadow tree when the type attribute changes This is often used on login forms, for example, to toggle the visibility of a password. The site will change the <input> element's type to "text" to allow the password to show.
2024-04-04 12:37:27 -04:00
void update_text_input_shadow_tree();
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<DOM::Element> m_inner_text_element;
GC::Ptr<DOM::Text> m_text_node;
LibWeb: Add basic support for <input type=checkbox> This is implemented entirely inside LibWeb, there is no GUI::CheckBox widget instantiated, unlike other input types. All input types should be moved to this new style of implementation.
2020-09-11 18:17:39 +02:00
bool m_checked { false };
LibWeb: Make <input type=checkbox> honor the "checked" attribute Implemented according to spec, although it's very possible that I missed one or two details. :^)
2022-02-15 19:16:57 +01:00
LibWeb: Refactor input color internal element updates to separate method
2024-01-18 20:17:47 +01:00
void update_color_well_element();
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<DOM::Element> m_color_well_element;
LibWeb: Refactor input color internal element updates to separate method
2024-01-18 20:17:47 +01:00
LibWeb: Create a shadow tree for <input type=file> elements This creates a button to prompt users to select a file, and a label to show information about the selected file(s). Clicking either shadow element will activate the input element.
2024-02-25 10:54:37 -05:00
void update_file_input_shadow_tree();
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<DOM::Element> m_file_button;
GC::Ptr<DOM::Element> m_file_label;
LibWeb: Create a shadow tree for <input type=file> elements This creates a button to prompt users to select a file, and a label to show information about the selected file(s). Clicking either shadow element will activate the input element.
2024-02-25 10:54:37 -05:00
LibWeb: Rename HTMLInputElement members related to range shadow tree Choose a better name for private members which were added in https://github.com/LadybirdBrowser/ladybird/pull/513
2024-07-16 11:31:29 -03:00
void update_slider_shadow_tree_elements();
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<DOM::Element> m_slider_runnable_track;
GC::Ptr<DOM::Element> m_slider_progress_element;
GC::Ptr<DOM::Element> m_slider_thumb;
LibWeb: Add basic input range rendering
2023-12-11 18:00:06 +01:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<DecodedImageData> image_data() const;
GC::Ptr<SharedResourceRequest> m_resource_request;
LibWeb: Implement HTMLInputElement's selected coordinates When an <input type=image> button is clicked, we now send the (x,y) coordinates of the click event (relative to the image) along with the form submission data. Regarding the text test, we can currently only test this feature with dialogs. The headless-browser test infrastructure cannot yet handle the resulting navigation that would occur if we were to test with normal form submission.
2024-02-19 00:21:27 -05:00
SelectedCoordinate m_selected_coordinate;
LibWeb: Begin implementing the HTMLInputElement 'image' type state This implements enough to represent <input type=image> with its loaded source image (or fallback to its alt text, if applicable). This does not implement acquring coordinates from user-activated click events on the image.
2024-02-18 21:12:14 -05:00
LibWeb: Implement the `HTMLInputElement` pattern attribute
2025-02-27 10:13:52 +00:00
Optional<Regex<ECMA262>> compiled_pattern_regular_expression() const;
LibWeb: Implement the `HTMLInputElement.list` attribute This returns the `HTMLDataListElement` pointed to by the `list` content attribute.
2025-03-03 15:23:48 +00:00
Optional<GC::Ref<HTMLDataListElement const>> suggestions_source_element() const;
LibWeb: Begin implementing the HTMLInputElement 'image' type state This implements enough to represent <input type=image> with its loaded source image (or fallback to its alt text, if applicable). This does not implement acquring coordinates from user-activated click events on the image.
2024-02-18 21:12:14 -05:00
Optional<DOM::DocumentLoadEventDelayer> m_load_event_delayer;
LibWeb: Implement indeterminate IDL attribute in HTMLInputElement
2023-03-20 04:34:43 -04:00
// https://html.spec.whatwg.org/multipage/input.html#dom-input-indeterminate
bool m_indeterminate { false };
LibWeb: Make <input type=checkbox> honor the "checked" attribute Implemented according to spec, although it's very possible that I missed one or two details. :^)
2022-02-15 19:16:57 +01:00
// https://html.spec.whatwg.org/multipage/input.html#concept-input-checked-dirty-flag
bool m_dirty_checkedness { false };
LibWeb: Refactor all LabelableNode subclasses + input event handling :^) This commit is messy due to the Paintable and Layout classes being tangled together. The RadioButton, CheckBox and ButtonBox classes are now subclasses of FormAssociatedLabelableNode. This subclass separates these layout nodes from LabelableNode, which is also the superclass of non-form associated labelable nodes (Progress). ButtonPaintable, CheckBoxPaintable and RadioButtonPaintable no longer call events on DOM nodes directly from their mouse event handlers; instead, all the functionality is now directly in EventHandler, which dispatches the related events. handle_mousedown and related methods return a bool indicating whether the event handling should proceed. Paintable classes can now return an alternative DOM::Node which should be the target of the mouse event. Labels use this to indicate that the labeled control should be the target of the mouse events. HTMLInputElement put its activation behavior on run_activation_behavior, which wasn't actually called anywhere and had to be manually called by other places. We now use activation_behavior which is used by EventDispatcher. This commit also brings HTMLInputElement closer to spec by removing the did_foo functions that did ad-hoc event dispatching and unifies the behavior under run_input_activation_behavior.
2022-03-14 23:05:55 +00:00
LibWeb: Handle input element value setting & getting closer to the spec We should not set the 'value' attribute when an input element's value is changed (by the user or programmatically). Instead, we should track the value internally and mark it with a dirty flag when it is changed.
2022-03-22 10:55:13 -04:00
// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-fe-dirty
bool m_dirty_value { false };
LibWeb: Implement CSS validity pseudo-classes
2025-02-02 20:41:23 +01:00
// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#user-validity
bool m_user_validity { false };
LibWeb: Refactor all LabelableNode subclasses + input event handling :^) This commit is messy due to the Paintable and Layout classes being tangled together. The RadioButton, CheckBox and ButtonBox classes are now subclasses of FormAssociatedLabelableNode. This subclass separates these layout nodes from LabelableNode, which is also the superclass of non-form associated labelable nodes (Progress). ButtonPaintable, CheckBoxPaintable and RadioButtonPaintable no longer call events on DOM nodes directly from their mouse event handlers; instead, all the functionality is now directly in EventHandler, which dispatches the related events. handle_mousedown and related methods return a bool indicating whether the event handling should proceed. Paintable classes can now return an alternative DOM::Node which should be the target of the mouse event. Labels use this to indicate that the labeled control should be the target of the mouse events. HTMLInputElement put its activation behavior on run_activation_behavior, which wasn't actually called anywhere and had to be manually called by other places. We now use activation_behavior which is used by EventDispatcher. This commit also brings HTMLInputElement closer to spec by removing the did_foo functions that did ad-hoc event dispatching and unifies the behavior under run_input_activation_behavior.
2022-03-14 23:05:55 +00:00
// https://html.spec.whatwg.org/multipage/input.html#the-input-element:legacy-pre-activation-behavior
bool m_before_legacy_pre_activation_behavior_checked { false };
LibWeb: Implement indeterminate IDL attribute in HTMLInputElement
2023-03-20 04:34:43 -04:00
bool m_before_legacy_pre_activation_behavior_indeterminate { false };
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<HTMLInputElement> m_legacy_pre_activation_behavior_checked_element_in_group;
LibWeb: Cache HTMLInputElement's parsed type attribute when it changes This will let us avoid parsing the type each time type() or type_state() are invoked.
2022-03-16 07:44:21 -04:00
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-03 23:39:53 -06:00
// https://html.spec.whatwg.org/multipage/input.html#concept-input-type-file-selected
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ptr<FileAPI::FileList> m_selected_files;
LibWeb: Implement <input type=file> behavior This includes punting on the actual file picker implementation all the way out to the PageClient. It's likely that some of the real details should be implemented somewhere closer, like the BrowsingContext or the Page, but we'll get there. For now, this allows https://copy.sh/v86 to load the emulation of the preselected images all the way until it hits a call to URL.createObjectURL.
2022-10-03 23:39:53 -06:00
LibWeb: Cache HTMLInputElement's parsed type attribute when it changes This will let us avoid parsing the type each time type() or type_state() are invoked.
2022-03-16 07:44:21 -04:00
TypeAttributeState m_type { TypeAttributeState::Text };
LibWeb: Port the FormAssociatedElement value to UTF-16 This porting effort makes it pretty clear we will want a UTF-16-aware GenericLexer. But for now, we can actually make ASCII assumptions about what we are parsing, and act accordingly.
2025-07-26 12:19:56 -04:00
Utf16String m_value;
LibWeb: Support committing changes to <input> elements We currently fire the change event on <input> elements when they lose focus. The spec allows for us to also fire the event when changes are "committed", so long as such an action makes sense for the input type. This patch detects when the return key is entered in an <input> element and uses that as the commit action for text-related types. If no change has occurred since the last commit, no change event is fired.
2023-11-30 12:54:30 -05:00
LibWeb: Handle <input> element type changing to the image button state The spec has special steps specific to the image button state to load the element's image URL.
2024-04-04 12:56:37 -04:00
String m_last_src_value;
LibWeb: Support committing changes to <input> elements We currently fire the change event on <input> elements when they lose focus. The spec allows for us to also fire the event when changes are "committed", so long as such an action makes sense for the input type. This patch detects when the return key is entered in an <input> element and uses that as the commit action for text-related types. If no change has occurred since the last commit, no change event is fired.
2023-11-30 12:54:30 -05:00
bool m_has_uncommitted_changes { false };
LibWeb: Support :open for file and color `<input>` elements
2025-01-31 15:34:34 +00:00
bool m_is_open { false };
LibWeb/HTML: Signal a type change Type changes are now signaled to radio buttons. This causes other radio buttons in the group to be unchecked if the input element is a checked radio button after the type change.
2025-04-20 19:48:47 +02:00
void signal_a_type_change();
LibWeb/HTML: Enforce constraints on range inputs This extends the sanitization algorithm for range inputs in order to prevent overflow, underflow and step mismatch.
2025-08-10 22:35:28 +02:00
bool is_number_underflowing(double number) const;
bool is_number_overflowing(double number) const;
bool is_number_mismatching_step(double number) const;
LibHTML: Implement basic <form> and <input> element support This patch adds "submit" inputs and default (text box) inputs, as well as form elements that can be submitted. Layout of input elements is implemented via a new LayoutWidget class that allows you to put an arbitrary GWidget in the layout tree. At the moment, the DOM node sets the initial size of the LayoutWidget, and then the positioning is done by the normal layout algorithm. We also now support submitting a <form method="GET">, which does a full replacing load with a URL based on the form's action + a query string built from the name/value of input elements within the submitted form. This is pretty neat! :^)
2019-11-25 21:21:55 +01:00
};
}
LibWeb: Add fast_is<T>() for various types stood out in a profile
2023-03-10 21:16:18 +01:00
namespace Web::DOM {
Meta: Enforce newlines around namespaces This has come up several times during code review, so let's just enforce it using a new clang-format 20 option.
2025-05-13 07:06:33 -04:00
LibWeb: Add fast_is<T>() for various types stood out in a profile
2023-03-10 21:16:18 +01:00
template<>
inline bool Node::fast_is<HTML::HTMLInputElement>() const { return is_html_input_element(); }
Meta: Enforce newlines around namespaces This has come up several times during code review, so let's just enforce it using a new clang-format 20 option.
2025-05-13 07:06:33 -04:00
LibWeb: Add fast_is<T>() for various types stood out in a profile
2023-03-10 21:16:18 +01:00
}
Reference in a new issue Copy permalink