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

350 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
/*
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
* Copyright (c) 2018-2022, Andreas Kling <kling@serenityos.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>
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
* Copyright (c) 2024, Jelle Raaijmakers <jelle@gmta.nl>
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 DOM::EditableTextNodeOwner
, 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);
LibWeb: Put most LibWeb GC objects in type-specific heap blocks With this change, we now have ~1200 CellAllocators across both LibJS and LibWeb in a normal WebContent instance. This gives us a minimum heap size of 4.7 MiB in the scenario where we only have one cell allocated per type. Of course, in practice there will be many more of each type, so the effective overhead is quite a bit smaller than that in practice. I left a few types unconverted to this mechanism because I got tired of doing this. :^)
2023-11-19 19:47:52 +01:00
JS_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 the layout tree GC-allocated This removes a set of complex reference cycles between DOM, layout tree and browsing context. It also makes lifetimes much easier to reason about, as the DOM and layout trees are now free to keep each other alive.
2022-10-17 14:41:50 +02:00
virtual JS::GCPtr<Layout::Node> create_layout_node(NonnullRefPtr<CSS::StyleProperties>) override;
LibWeb: Add element adjust_computed_style and move set_property() to it
2024-03-07 21:27:37 +01:00
virtual void adjust_computed_style(CSS::StyleProperties&) 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: 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
enum class ChangeSource {
Programmatic,
User,
};
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(bool, ChangeSource = ChangeSource::Programmatic);
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: Handle immutable state for HTMLInputElement pickers Which should not be shown if the element is not mutable.
2023-09-03 00:17:37 +12:00
bool is_mutable() const { return m_is_mutable; }
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
void did_select_files(Span<SelectedFile> selected_files);
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
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
JS::GCPtr<FileAPI::FileList> files();
void set_files(JS::GCPtr<FileAPI::FileList>);
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
void update_the_file_selection(JS::NonnullGCPtr<FileAPI::FileList>);
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: Add support for the input size attribute
2023-11-24 17:37:53 +01:00
unsigned size() const;
WebIDL::ExceptionOr<void> set_size(unsigned 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;
WebIDL::ExceptionOr<void> set_value_as_date(Optional<JS::Handle<JS::Object>> const&);
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: 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
// ^DOM::EditableTextNodeOwner
LibWeb: Move the navigable's cursor position to be owned by the document Navigables are re-used for navigations within the same tab. Its current ownership of the cursor position is a bit ad-hoc, so nothing in the spec indicates when to reset the cursor, nor do we manually do so. So when a cursor update happens on one page, that cursor is retained on the next page. Instead, let's have the document own the cursor. Each navigation results in a new document, thus we don't need to worry about resetting cursors. This also makes many of the callsites feel nicer. We were previously often going from the node, to the document, to the navigable, to the cursor. This patch removes the navigable hop.
2024-08-02 07:31:40 -04:00
virtual void did_edit_text_node(Badge<DOM::Document>) override;
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
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
virtual bool is_focusable() const override { return m_type != TypeAttributeState::Hidden; }
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: 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: Reset form association when the element's form attribute changes
2024-02-03 09:33:33 -05:00
virtual void form_associated_element_attribute_changed(FlyString const&, Optional<String> 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: Implement cloning steps for `HTMLInputElement`
2024-08-21 12:19:37 +01:00
virtual WebIDL::ExceptionOr<void> cloned(Node&, bool) override;
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
JS::NonnullGCPtr<ValidityState const> validity() const;
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
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
JS::GCPtr<Element> placeholder_element() { return m_placeholder_element; }
JS::GCPtr<Element const> placeholder_element() const { return m_placeholder_element; }
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: 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: 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
protected:
LibWeb: Update the document cursor position when the selection changes Otherwise, it looks a bit awkward where the cursor position does not update while the selection is elsewhere. Note that this requires passing along the raw selection positions from `set the selection range` to the elements. Otherwise, consider what will happen if we set the selection start and end to the same value. By going through the API accessor, we hit the case where the start and end are the same value, and return the document cursor position. This would mean the cursor position would not be updated. The test changes here more closely match what Firefox produces now. It is not a 100% match; the `select event fired` test case isn't right. The problem is the event fires for the input element, but we most recently focused the textarea element. Thus, when we retrieve the selection from the input element, we return the document's cursor position, which is actually in the textarea element. The fix will ultimately be to fully implement the following: https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-textarea/input-cursor That is, each input / textarea element should separately track its own text cursor position.
2024-08-27 10:46:34 -04:00
void selection_was_changed(size_t selection_start, size_t selection_end) override;
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: 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: Support `accent-color` for range input and progress element Fixes #466
2024-07-11 17:47:25 -03:00
virtual void computed_css_values_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;
LibWeb: Visit ImageProvider from Layout::ImageBox Adds missing visit of HTMLElement that serves as image provider of image layout node.
2024-02-26 17:36:48 +01:00
virtual JS::NonnullGCPtr<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
LibWeb: Add input element valueAsDate property
2023-12-15 18:23:29 +01:00
WebIDL::ExceptionOr<JS::GCPtr<JS::Date>> convert_string_to_date(StringView input) const;
String covert_date_to_string(JS::NonnullGCPtr<JS::Date> input) const;
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();
JS::GCPtr<DOM::Element> m_placeholder_element;
JS::GCPtr<DOM::Text> m_placeholder_text_node;
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();
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
JS::GCPtr<DOM::Element> m_inner_text_element;
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
JS::GCPtr<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();
JS::GCPtr<DOM::Element> m_color_well_element;
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();
JS::GCPtr<DOM::Element> m_file_button;
JS::GCPtr<DOM::Element> m_file_label;
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();
LibWeb: Add basic input range rendering
2023-12-11 18:00:06 +01:00
JS::GCPtr<DOM::Element> m_slider_thumb;
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
JS::GCPtr<DOM::Element> m_slider_progress_element;
LibWeb: Add basic input range rendering
2023-12-11 18:00:06 +01: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
JS::GCPtr<DecodedImageData> image_data() const;
LibWeb: Rename SharedImageRequest to SharedResourceRequest For the SVG <use> element, we want to support loading HTML documents that have a SVG element inside of it pointed to by the URL fragment. In this situation we would need to fetch and parse the entire document in SharedImageRequest (so that we can still cache the SVGs). Rename SharedImageRequest to SharedResourceRequest to make the class a little more generic for future usecases.
2024-08-03 15:27:08 +12:00
JS::GCPtr<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: Support readonly attribute for input elements
2023-09-03 00:07:58 +12:00
// https://html.spec.whatwg.org/multipage/input.html#the-input-element:concept-fe-mutable
bool m_is_mutable { true };
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 };
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
JS::GCPtr<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
JS::GCPtr<FileAPI::FileList> m_selected_files;
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