mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-23 17:52:26 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/HTML/HTMLInputElement.h

361 lines
14 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: 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: 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: 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: 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: 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
class HTMLInputElement final
: 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: 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
, public Layout::ImageProvider {
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: 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
FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLInputElement)
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 HTMLInputElement from DeprecatedString to String And dealing with the fallout of doing so. I am not 100% sure that it is safe for us to be treating Strings in the value sanitization algorithm in all cases as if they are ASCII, but this commit does not change any existing behaviour there.
2023-11-20 20:32:40 +13:00
virtual String value() const override;
LibWeb: Port HTMLInputElement interface from DeprecatedString to String
2023-09-03 16:27:10 +12:00
WebIDL::ExceptionOr<void> set_value(String 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
virtual String relevant_value() override { return 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
WebIDL::ExceptionOr<void> set_relevant_value(String const& value) override { return set_value(value); }
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: 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: 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: 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: Stub out a few form validation and selection methods
2023-03-04 23:58:25 +01:00
WebIDL::ExceptionOr<bool> check_validity();
WebIDL::ExceptionOr<bool> report_validity();
LibWeb: Port HTMLInputElement interface from DeprecatedString to String
2023-09-03 16:27:10 +12:00
void set_custom_validity(String const&);
LibWeb: Stub out a few form validation and selection methods
2023-03-04 23:58:25 +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
virtual bool is_auto_capitalize_inheriting() const override { return true; }
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: Remove shadow roots from elements that are removed from the DOM We currently create a shadow tree once for each DOM element that renders with a shadow tree (e.g. <input>, <details>). If such an element is removed from the DOM, we must remove its shadow tree. Otherwise, the shadow tree will refer to the old document in perpetuity. If the node is added back to a DOM, then recreate the shadow tree.
2023-11-29 18:22:16 -05:00
virtual void form_associated_element_was_removed(DOM::Node*) override;
LibWeb: Include namespace parameter in `associated_attribute_changed()`
2024-12-12 19:48:32 +00:00
virtual void form_associated_element_attribute_changed(FlyString const&, Optional<String> const&, Optional<FlyString> const&) 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
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::Ref<ValidityState const> validity() const;
LibWeb: Add stub for ValidityState This fixes https://html5test.com/ as previously an exception was being thrown after trying to access this attribute which would then result in a popup about the test failing (and none of the test results being shown).
2024-06-09 15:13:38 +12: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/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: 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: 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: Make CSS::ComputedProperties GC-allocated
2024-12-20 16:35:12 +01:00
virtual void computed_properties_changed() 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;
virtual RefPtr<Gfx::ImmutableBitmap> current_image_bitmap(Gfx::IntSize = {}) const override;
virtual void set_visible_in_viewport(bool) 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::Ref<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: 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: Fix typo: covert_number_to_string => convert_number_to_string
2024-04-03 18:17:24 +02:00
String 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;
String covert_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: 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: Port handle_readonly_attribute from DeprecatedFlyString It's a little awkward that one caller of this is passing through an Optional<String> and another an Optional<DeprecatedString>, but that should be fixed some point in the future with further DeprecatedString porting.
2023-11-05 12:17:24 +13:00
void handle_readonly_attribute(Optional<String> const& value);
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 HTMLInputElement from DeprecatedString to String And dealing with the fallout of doing so. I am not 100% sure that it is safe for us to be treating Strings in the value sanitization algorithm in all cases as if they are ASCII, but this commit does not change any existing behaviour there.
2023-11-20 20:32:40 +13:00
String value_sanitization_algorithm(String 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
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: 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 HTMLInputElement from DeprecatedString to String And dealing with the fallout of doing so. I am not 100% sure that it is safe for us to be treating Strings in the value sanitization algorithm in all cases as if they are ASCII, but this commit does not change any existing behaviour there.
2023-11-20 20:32:40 +13:00
String 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 };
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 {
template<>
inline bool Node::fast_is<HTML::HTMLInputElement>() const { return is_html_input_element(); }
}
Reference in a new issue Copy permalink