dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / html / html_input_element_3.lucb
#==============================================================================================
#
# html_input_element_3 - HTML::HTMLInputElement: the user-agent shadow trees
#
# DESCRIPTION:
# Port of LibWeb/HTML/HTMLInputElement.cpp (lines 1052-1493): creating the shadow tree
# of the element's type (button label, text field with inner text, placeholder and
# stepper buttons, color well, file button and label, range slider track, fill and
# thumb) and updating it, the native event listeners of the stepper buttons, the file
# button and the slider (JS::NativeFunctions whose captures are the element, or a struct
# allocated with `new`), and the input events of user interaction.
#
#==============================================================================================
# mark: Helpers =================================================================================
## `Utf16String::formatted(fmtstr, arguments...)` with AK's format specifications.
func html_utf16_formatted(fmtstr: str, arguments: const ak.TypeErasedParameter[]) -> ak.Utf16String:
var builder = ak.string_builder_new_mode(ak.StringBuilderMode.utf16)
ak.vformat_arguments(&builder, ak.sv(fmtstr), arguments) else trap("MUST: Utf16String::formatted")
return ak.string_builder_to_utf16_string(&builder)
## `MUST(String::formatted(fmtstr, arguments...))` with AK's format specifications.
func html_string_formatted(fmtstr: str, arguments: const ak.TypeErasedParameter[]) -> ak.String:
var builder = ak.string_builder_new()
ak.vformat_arguments(&builder, ak.sv(fmtstr), arguments) else trap("MUST: String::formatted")
return ak.string_from_string_builder(&builder) else trap("MUST: String::formatted")
## `MUST(DOM::create_element(document, local_name, namespace_))`.
func html_input_element_create_element(this: HtmlInputElement*, local_name: ak.FlyString, namespace_: ak.FlyString) -> DomElement*:
return dom_create_element(html_input_element_document(this), local_name, namespace_) else trap("MUST: DOM::create_element")
## `MUST(parent->append_child(child))`.
func html_append_child(parent: DomNode*, child: DomNode*):
_ = dom_node_append_child(parent, child) else trap("MUST: append_child")
## `realm().heap().allocate<WebIDL::CallbackType>(*JS::NativeFunction::create(realm(), behaviour, 0, {}, &realm()), realm())`.
func html_input_element_native_callback(this: HtmlInputElement*, call: func(void*?, Vm*) -> JsValue!, context: void*) -> IdlCallbackType*:
let realm = html_input_element_realm(this)
let function = js_native_function_create(realm, JsNativeFunctionBehaviour(call = call, context = context), 0, ak.utf16_fly_string_new(), realm)
return realm_create_idl_callback_type_realm(realm, (JsObject*)function, realm, IdlOperationReturnsPromise.no)
# mark: Creating and updating the shadow tree ===================================================
## Ported from HTMLInputElement.cpp:1052 Web::HTML::HTMLInputElement::create_shadow_tree_if_needed.
func html_input_element_create_shadow_tree_if_needed(this: HtmlInputElement*):
if dom_element_shadow_root(this.dom_element()) != none:
return
match html_input_element_type_state(this):
.hidden, .radio_button, .checkbox:
_ = this
.button, .submit_button, .reset_button:
html_input_element_create_button_input_shadow_tree(this)
.image_button:
_ = this
.color:
html_input_element_create_color_input_shadow_tree(this)
.file_upload:
html_input_element_create_file_input_shadow_tree(this)
.range:
html_input_element_create_range_input_shadow_tree(this)
# FIXME: This could be better factored. Everything except the above types becomes a text input.
_:
html_input_element_create_text_input_shadow_tree(this)
## Ported from HTMLInputElement.cpp:1085 Web::HTML::HTMLInputElement::update_shadow_tree.
func html_input_element_update_shadow_tree(this: HtmlInputElement*):
match html_input_element_type_state(this):
.color:
html_input_element_update_color_well_element(this)
.file_upload:
html_input_element_update_file_input_shadow_tree(this)
.range:
html_input_element_update_slider_shadow_tree_elements(this)
.button, .reset_button, .submit_button:
html_input_element_update_button_input_shadow_tree(this)
_:
html_input_element_update_text_input_shadow_tree(this)
## Ported from HTMLInputElement.cpp:1108 Web::HTML::HTMLInputElement::create_button_input_shadow_tree.
func html_input_element_create_button_input_shadow_tree(this: HtmlInputElement*):
let realm = html_input_element_realm(this)
let document = html_input_element_document(this)
let shadow_root = realm_create_dom_shadow_root(realm, document, this.dom_element(), BindShadowRootMode.closed)
dom_shadow_root_set_user_agent_internal(shadow_root, true)
dom_element_set_shadow_root(this.dom_element(), shadow_root)
let text_container = html_input_element_create_element(this, html_tag_names_span, namespace_html)
dom_element_set_attribute_value(text_container, html_attribute_names_style, ak.string_from_str("display: inline-block; pointer-events: none;"))
let text_node = realm_create_dom_text_utf16_string(realm, document, html_input_element_button_label(this))
this.m_text_node = text_node
html_append_child(text_container.dom_node(), text_node.dom_node())
html_append_child(shadow_root.dom_node(), text_container.dom_node())
## `static GC::Root<CSS::CSSStyleProperties> style` of the outer element in create_text_input_shadow_tree().
var html_input_element_create_text_input_shadow_tree_s_element_style: gc.Root[CssStyleProperties]
## `static GC::Root<CSS::CSSStyleProperties> style` of the inner text element in create_text_input_shadow_tree().
var html_input_element_create_text_input_shadow_tree_s_inner_text_style: gc.Root[CssStyleProperties]
## The static inline styles of the input elements' shadow trees forgotten as their VM is
## destroyed (vm_destroy): they are cells of the internal CSS realm, and C++'s statics live as long
## as the process's one VM.
func html_input_element_forget_static_styles():
gc.root_release(&html_inner_text_style_when_visible_s_style)
gc.root_release(&html_inner_text_style_when_hidden_s_style)
gc.root_release(&html_stepper_button_style_when_visible_s_style)
gc.root_release(&html_stepper_button_style_when_hidden_s_style)
gc.root_release(&html_placeholder_style_when_visible_s_style)
gc.root_release(&html_placeholder_style_when_hidden_s_style)
gc.root_release(&html_input_element_create_text_input_shadow_tree_s_element_style)
gc.root_release(&html_input_element_create_text_input_shadow_tree_s_inner_text_style)
## The mouseup listener of the stepper buttons: `[this](JS::VM&) { commit_pending_changes(); ... }`.
func html_input_element_stepper_mouseup(context: void*?, vm: Vm*) -> JsValue!:
_ = vm
let this = (HtmlInputElement*)(context else trap("no input element"))
html_input_element_commit_pending_changes(this)
return js_undefined()
## The mousedown listener of the up button.
func html_input_element_stepper_up(context: void*?, vm: Vm*) -> JsValue!:
_ = vm
let this = (HtmlInputElement*)(context else trap("no input element"))
if html_input_element_type_state(this) == HtmlInputElementTypeAttributeState.number and html_input_element_is_mutable_impl(html_input_element_form_associated(this)) and html_input_element_allowed_value_step(this) != none:
html_input_element_step_up(this) else trap("MUST: step_up")
html_input_element_user_interaction_did_change_input_value(this)
return js_undefined()
## The mousedown listener of the down button.
func html_input_element_stepper_down(context: void*?, vm: Vm*) -> JsValue!:
_ = vm
let this = (HtmlInputElement*)(context else trap("no input element"))
if html_input_element_type_state(this) == HtmlInputElementTypeAttributeState.number and html_input_element_is_mutable_impl(html_input_element_form_associated(this)) and html_input_element_allowed_value_step(this) != none:
html_input_element_step_down(this) else trap("MUST: step_down")
html_input_element_user_interaction_did_change_input_value(this)
return js_undefined()
## Ported from HTMLInputElement.cpp:1121 Web::HTML::HTMLInputElement::create_text_input_shadow_tree.
func html_input_element_create_text_input_shadow_tree(this: HtmlInputElement*):
let realm = html_input_element_realm(this)
let document = html_input_element_document(this)
let shadow_root = realm_create_dom_shadow_root(realm, document, this.dom_element(), BindShadowRootMode.closed)
dom_shadow_root_set_user_agent_internal(shadow_root, true)
dom_element_set_shadow_root(this.dom_element(), shadow_root)
let element = html_input_element_create_element(this, html_tag_names_div, namespace_html)
dom_element_set_inline_style(element, html_input_element_static_style(&html_input_element_create_text_input_shadow_tree_s_element_style, "\n display: flex;\n height: 100%;\n align-items: center;\n white-space: pre;\n border: none;\n padding: 1px 2px;\n "))
html_append_child(shadow_root.dom_node(), element.dom_node())
# https://www.w3.org/TR/css-ui-4/#input-rules
let inner_text_element = html_input_element_create_element(this, html_tag_names_div, namespace_html)
this.m_inner_text_element = inner_text_element
dom_element_set_inline_style(inner_text_element, html_input_element_static_style(&html_input_element_create_text_input_shadow_tree_s_inner_text_style, "\n width: 100%;\n height: 1lh;\n align-items: center;\n overflow: auto;\n scrollbar-width: none;\n text-overflow: clip;\n white-space: nowrap;\n "))
html_append_child(element.dom_node(), inner_text_element.dom_node())
let text_node = realm_create_dom_text_utf16_string(realm, document, this.m_value)
this.m_text_node = text_node
if html_input_element_type_state(this) == HtmlInputElementTypeAttributeState.password:
dom_text_set_is_password_input(text_node, true)
html_input_element_handle_maxlength_attribute(this)
html_append_child(inner_text_element.dom_node(), text_node.dom_node())
let placeholder_element = html_input_element_create_element(this, html_tag_names_div, namespace_html)
this.m_placeholder_element = placeholder_element
dom_element_set_use_pseudo_element(placeholder_element, css_data.PseudoElement.placeholder)
html_append_child(element.dom_node(), placeholder_element.dom_node())
let placeholder = html_input_element_placeholder(this)
let placeholder_text_node = realm_create_dom_text_utf16_string(realm, document, ak.utf16_string_from_utf8_string(&placeholder))
this.m_placeholder_text_node = placeholder_text_node
html_append_child(placeholder_element.dom_node(), placeholder_text_node.dom_node())
if html_input_element_type_state(this) == HtmlInputElementTypeAttributeState.number:
# Up button
let up_button_element = html_input_element_create_element(this, html_tag_names_button, namespace_html)
this.m_up_button_element = up_button_element
let up_button_svg = html_input_element_create_element(this, svg_tag_names_svg, namespace_svg)
dom_element_set_attribute_value(up_button_svg, html_attribute_names_style, ak.string_from_str("width: 1em; height: 1em;"))
dom_element_set_attribute_value(up_button_svg, svg_attribute_names_xmlns, ak.fly_string_to_string_const(&namespace_svg))
dom_element_set_attribute_value(up_button_svg, svg_attribute_names_view_box, ak.string_from_str("0 0 24 24"))
html_append_child(up_button_element.dom_node(), up_button_svg.dom_node())
let up_button_svg_path = html_input_element_create_element(this, svg_tag_names_path, namespace_svg)
dom_element_set_attribute_value(up_button_svg_path, svg_attribute_names_fill, ak.string_from_str("currentColor"))
dom_element_set_attribute_value(up_button_svg_path, svg_attribute_names_d, ak.string_from_str("M7.41,15.41L12,10.83L16.59,15.41L18,14L12,8L6,14L7.41,15.41Z"))
html_append_child(up_button_svg.dom_node(), up_button_svg_path.dom_node())
html_append_child(element.dom_node(), up_button_element.dom_node())
let mouseup_callback = html_input_element_native_callback(this, html_input_element_stepper_mouseup, this)
var mouseup_listener_options = DomAddEventListenerOptions(event_listener_options = DomEventListenerOptions(), passive = none, once = false, signal = none)
mouseup_listener_options.once = true
# (The options are not passed on: the listeners below are added without options, as in the C++.)
_ = mouseup_listener_options
let step_up_callback = html_input_element_native_callback(this, html_input_element_stepper_up, this)
dom_event_target_add_event_listener_without_options(up_button_element.dom_event_target(), ui_events_event_names_mousedown, dom_idl_event_listener_create(realm, step_up_callback))
dom_event_target_add_event_listener_without_options(up_button_element.dom_event_target(), ui_events_event_names_mouseup, dom_idl_event_listener_create(realm, mouseup_callback))
# Down button
let down_button_element = html_input_element_create_element(this, html_tag_names_button, namespace_html)
this.m_down_button_element = down_button_element
let down_button_svg = html_input_element_create_element(this, svg_tag_names_svg, namespace_svg)
dom_element_set_attribute_value(down_button_svg, html_attribute_names_style, ak.string_from_str("width: 1em; height: 1em;"))
dom_element_set_attribute_value(down_button_svg, svg_attribute_names_xmlns, ak.fly_string_to_string_const(&namespace_svg))
dom_element_set_attribute_value(down_button_svg, svg_attribute_names_view_box, ak.string_from_str("0 0 24 24"))
html_append_child(down_button_element.dom_node(), down_button_svg.dom_node())
let down_button_svg_path = html_input_element_create_element(this, svg_tag_names_path, namespace_svg)
dom_element_set_attribute_value(down_button_svg_path, svg_attribute_names_fill, ak.string_from_str("currentColor"))
dom_element_set_attribute_value(down_button_svg_path, svg_attribute_names_d, ak.string_from_str("M7.41,8.58L12,13.17L16.59,8.58L18,10L12,16L6,10L7.41,8.58Z"))
html_append_child(down_button_svg.dom_node(), down_button_svg_path.dom_node())
html_append_child(element.dom_node(), down_button_element.dom_node())
let step_down_callback = html_input_element_native_callback(this, html_input_element_stepper_down, this)
dom_event_target_add_event_listener_without_options(down_button_element.dom_event_target(), ui_events_event_names_mousedown, dom_idl_event_listener_create(realm, step_down_callback))
dom_event_target_add_event_listener_without_options(down_button_element.dom_event_target(), ui_events_event_names_mouseup, dom_idl_event_listener_create(realm, mouseup_callback))
html_input_element_update_text_input_shadow_tree(this)
## Ported from HTMLInputElement.cpp:1251 Web::HTML::HTMLInputElement::create_color_input_shadow_tree.
func html_input_element_create_color_input_shadow_tree(this: HtmlInputElement*):
let shadow_root = realm_create_dom_shadow_root(html_input_element_realm(this), html_input_element_document(this), this.dom_element(), BindShadowRootMode.closed)
dom_shadow_root_set_user_agent_internal(shadow_root, true)
let color = html_input_element_value_sanitization_algorithm(this, this.m_value)
let border = dom_create_element(html_input_element_document(this), html_tag_names_div, namespace_html) else trap("FIXME: should propagate errors")
dom_element_set_attribute_value(border, html_attribute_names_style, ak.string_from_str("\n width: fit-content;\n height: fit-content;\n padding: 4px;\n border: 1px solid ButtonBorder;\n background-color: ButtonFace;\n"))
let color_well_element = dom_create_element(html_input_element_document(this), html_tag_names_div, namespace_html) else trap("FIXME: should propagate errors")
this.m_color_well_element = color_well_element
dom_element_set_attribute_value(color_well_element, html_attribute_names_style, ak.string_from_str("\n width: 32px;\n height: 16px;\n border: 1px solid ButtonBorder;\n box-sizing: border-box;\n"))
let color_text = ak.utf16_string_base_to_utf8_but_should_be_ported_to_utf16(&color.utf16_string_base)
css_style_properties_set_property_property_id(dom_element_style_for_bindings(color_well_element), css_data.PropertyId.background_color, ak.string_bytes_as_string_view(&color_text), ak.sv("")) else trap("MUST: set_property")
html_append_child(border.dom_node(), color_well_element.dom_node())
html_append_child(shadow_root.dom_node(), border.dom_node())
dom_element_set_shadow_root(this.dom_element(), shadow_root)
## Ported from HTMLInputElement.cpp:1281 Web::HTML::HTMLInputElement::update_color_well_element.
func html_input_element_update_color_well_element(this: HtmlInputElement*):
let color_well_element = this.m_color_well_element else return
let value_text = ak.utf16_string_base_to_utf8_but_should_be_ported_to_utf16(&this.m_value.utf16_string_base)
css_style_properties_set_property_property_id(dom_element_style_for_bindings(color_well_element), css_data.PropertyId.background_color, ak.string_bytes_as_string_view(&value_text), ak.sv("")) else trap("MUST: set_property")
## The click listener of the file button: `[this](JS::VM&) { show_the_picker_if_applicable(*this); ... }`.
func html_input_element_file_button_click(context: void*?, vm: Vm*) -> JsValue!:
_ = vm
let this = (HtmlInputElement*)(context else trap("no input element"))
html_show_the_picker_if_applicable(this)
return js_undefined()
## Ported from HTMLInputElement.cpp:1289 Web::HTML::HTMLInputElement::create_file_input_shadow_tree.
func html_input_element_create_file_input_shadow_tree(this: HtmlInputElement*):
let realm = html_input_element_realm(this)
let document = html_input_element_document(this)
let shadow_root = realm_create_dom_shadow_root(realm, document, this.dom_element(), BindShadowRootMode.closed)
dom_shadow_root_set_user_agent_internal(shadow_root, true)
let file_button = dom_create_element(document, html_tag_names_button, namespace_html) else trap("FIXME: should propagate errors")
this.m_file_button = file_button
dom_element_set_use_pseudo_element(file_button, css_data.PseudoElement.file_selector_button)
let file_label = dom_create_element(document, html_tag_names_label, namespace_html) else trap("FIXME: should propagate errors")
this.m_file_label = file_label
dom_element_set_attribute_value(file_label, html_attribute_names_style, ak.string_from_str("padding-left: 4px;"))
let on_button_click_callback = html_input_element_native_callback(this, html_input_element_file_button_click, this)
dom_event_target_add_event_listener_without_options(file_button.dom_event_target(), ui_events_event_names_click, dom_idl_event_listener_create(realm, on_button_click_callback))
html_input_element_update_file_input_shadow_tree(this)
html_append_child(shadow_root.dom_node(), file_button.dom_node())
html_append_child(shadow_root.dom_node(), file_label.dom_node())
dom_element_set_shadow_root(this.dom_element(), shadow_root)
## Ported from HTMLInputElement.cpp:1319 Web::HTML::HTMLInputElement::update_file_input_shadow_tree.
func html_input_element_update_file_input_shadow_tree(this: HtmlInputElement*):
let file_button = this.m_file_button else return
let file_label = this.m_file_label else return
let files_label = "files" if html_input_element_has_attribute(this, html_attribute_names_multiple) else "file"
dom_node_string_replace_all(file_button.dom_node(), html_utf16_formatted("Select {}...", [ak.arg_str(files_label)]))
let selected_files = this.m_selected_files
if selected_files != none and file_api_file_list_length(selected_files else trap("unreachable")) > 0:
let files = selected_files else trap("unreachable")
if file_api_file_list_length(files) == 1:
let name = file_api_file_name(file_api_file_list_item(files, 0) else trap("VERIFY: FileList::item"))
dom_node_string_replace_all(file_label.dom_node(), ak.utf16_string_from_utf8_string(&name))
else:
dom_node_string_replace_all(file_label.dom_node(), html_utf16_formatted("{} files selected.", [ak.arg_u64(file_api_file_list_length(files))]))
else:
dom_node_string_replace_all(file_label.dom_node(), html_utf16_formatted("No {} selected.", [ak.arg_str(files_label)]))
## The keydown listener of the slider.
func html_input_element_slider_keydown(context: void*?, vm: Vm*) -> JsValue!:
let this = (HtmlInputElement*)(context else trap("no input element"))
if html_input_element_type_state(this) != HtmlInputElementTypeAttributeState.range:
return js_undefined()
if html_input_element_allowed_value_step(this) == none:
return js_undefined()
let key_value = js_value_get(vm_argument(vm, 0), vm, ak.utf16_fly_string_from_utf8_string_view(ak.sv("key"))) else trap("MUST: get")
if not js_value_is_string(key_value):
return js_undefined()
let key = js_value_as_string_utf8_string(key_value)
if ak.string_eq_string_view(&key, ak.sv("ArrowLeft")) or ak.string_eq_string_view(&key, ak.sv("ArrowDown")):
html_input_element_step_down(this) else trap("MUST: step_down")
if ak.string_eq_string_view(&key, ak.sv("PageDown")):
html_input_element_step_down(this, 10) else trap("MUST: step_down")
if ak.string_eq_string_view(&key, ak.sv("ArrowRight")) or ak.string_eq_string_view(&key, ak.sv("ArrowUp")):
html_input_element_step_up(this) else trap("MUST: step_up")
if ak.string_eq_string_view(&key, ak.sv("PageUp")):
html_input_element_step_up(this, 10) else trap("MUST: step_up")
html_input_element_user_interaction_did_change_input_value(this)
return js_undefined()
## The wheel listener of the slider.
func html_input_element_slider_wheel(context: void*?, vm: Vm*) -> JsValue!:
let this = (HtmlInputElement*)(context else trap("no input element"))
if html_input_element_type_state(this) != HtmlInputElementTypeAttributeState.range:
return js_undefined()
if html_input_element_allowed_value_step(this) == none:
return js_undefined()
let delta_y_value = js_value_get(vm_argument(vm, 0), vm, ak.utf16_fly_string_from_utf8_string_view(ak.sv("deltaY"))) else trap("MUST: get")
if not js_value_is_finite_number(delta_y_value):
return js_undefined()
if js_value_as_double(delta_y_value) > 0.0:
html_input_element_step_down(this) else trap("MUST: step_down")
else:
html_input_element_step_up(this) else trap("MUST: step_up")
html_input_element_user_interaction_did_change_input_value(this)
return js_undefined()
## `update_slider_by_mouse`: `[this](JS::VM& vm) { ... }`.
func html_input_element_update_slider_by_mouse(this: HtmlInputElement*, vm: Vm*):
if html_input_element_type_state(this) != HtmlInputElementTypeAttributeState.range:
return
let client_x_value = js_value_get(vm_argument(vm, 0), vm, ak.utf16_fly_string_from_utf8_string_view(ak.sv("clientX"))) else trap("MUST: get")
if not js_value_is_finite_number(client_x_value):
return
let client_x = js_value_as_double(client_x_value)
let rect = dom_element_get_bounding_client_rect(this.dom_element())
if gfx.css_pixel_rect_width(&rect).to_double() <= 0.0:
return
let minimum = html_input_element_min(this) else trap("VERIFY: Optional::operator*")
let maximum = html_input_element_max(this) else trap("VERIFY: Optional::operator*")
if minimum > maximum:
return
# FIXME: Snap new value to input steps
html_input_element_set_value_as_number(this, ak.clamp_f64(math.round(((client_x - gfx.css_pixel_rect_left(&rect).to_double()) / gfx.css_pixel_rect_width(&rect).to_double()) * (maximum - minimum) + minimum), minimum, maximum)) else trap("MUST: set_value_as_number")
html_input_element_user_interaction_did_change_input_value(this)
## The window's mousemove listener while the slider is dragged: `[update_slider_by_mouse](JS::VM& vm) { ... }`.
func html_input_element_slider_mousemove(context: void*?, vm: Vm*) -> JsValue!:
let this = (HtmlInputElement*)(context else trap("no input element"))
html_input_element_update_slider_by_mouse(this, vm)
return js_undefined()
## The captures of the window's mouseup listener: `[this, mousemove_listener]`.
struct HtmlInputElementSliderMouseup:
var this: HtmlInputElement*
var mousemove_listener: DomIdlEventListener*
## The window's mouseup listener that ends a drag of the slider.
func html_input_element_slider_mouseup(context: void*?, vm: Vm*) -> JsValue!:
_ = vm
let captures = (HtmlInputElementSliderMouseup*)(context else trap("no captures"))
let window = (HtmlWindow*)html_relevant_global_object((JsObject*)captures.this)
dom_event_target_remove_event_listener_without_options(window.dom_event_target(), ui_events_event_names_mousemove, captures.mousemove_listener)
return js_undefined()
## The mousedown listener of the slider.
func html_input_element_slider_mousedown(context: void*?, vm: Vm*) -> JsValue!:
let this = (HtmlInputElement*)(context else trap("no input element"))
let realm = html_input_element_realm(this)
html_input_element_update_slider_by_mouse(this, vm)
let mousemove_callback = html_input_element_native_callback(this, html_input_element_slider_mousemove, this)
let mousemove_listener = dom_idl_event_listener_create(realm, mousemove_callback)
let window = (HtmlWindow*)html_relevant_global_object((JsObject*)this)
dom_event_target_add_event_listener_without_options(window.dom_event_target(), ui_events_event_names_mousemove, mousemove_listener)
let captures = new HtmlInputElementSliderMouseup(this = this, mousemove_listener = mousemove_listener) else trap("out of memory")
let mouseup_callback = html_input_element_native_callback(this, html_input_element_slider_mouseup, captures)
var mouseup_listener_options = DomAddEventListenerOptions(event_listener_options = DomEventListenerOptions(), passive = none, once = false, signal = none)
mouseup_listener_options.once = true
dom_event_target_add_event_listener(window.dom_event_target(), ui_events_event_names_mouseup, dom_idl_event_listener_create(realm, mouseup_callback), .dom_add_event_listener_options(mouseup_listener_options))
return js_undefined()
## Ported from HTMLInputElement.cpp:1337 Web::HTML::HTMLInputElement::create_range_input_shadow_tree.
func html_input_element_create_range_input_shadow_tree(this: HtmlInputElement*):
let realm = html_input_element_realm(this)
let shadow_root = realm_create_dom_shadow_root(realm, html_input_element_document(this), this.dom_element(), BindShadowRootMode.closed)
dom_shadow_root_set_user_agent_internal(shadow_root, true)
dom_element_set_shadow_root(this.dom_element(), shadow_root)
let slider_runnable_track = html_input_element_create_element(this, html_tag_names_div, namespace_html)
this.m_slider_runnable_track = slider_runnable_track
dom_element_set_use_pseudo_element(slider_runnable_track, css_data.PseudoElement.slider_track)
html_append_child(shadow_root.dom_node(), slider_runnable_track.dom_node())
let slider_progress_element = html_input_element_create_element(this, html_tag_names_div, namespace_html)
this.m_slider_progress_element = slider_progress_element
dom_element_set_use_pseudo_element(slider_progress_element, css_data.PseudoElement.slider_fill)
html_append_child(slider_runnable_track.dom_node(), slider_progress_element.dom_node())
let slider_thumb = html_input_element_create_element(this, html_tag_names_div, namespace_html)
this.m_slider_thumb = slider_thumb
dom_element_set_use_pseudo_element(slider_thumb, css_data.PseudoElement.slider_thumb)
html_append_child(slider_runnable_track.dom_node(), slider_thumb.dom_node())
html_input_element_update_slider_shadow_tree_elements(this)
let keydown_callback = html_input_element_native_callback(this, html_input_element_slider_keydown, this)
dom_event_target_add_event_listener_without_options(this.dom_event_target(), ui_events_event_names_keydown, dom_idl_event_listener_create(realm, keydown_callback))
let wheel_callback = html_input_element_native_callback(this, html_input_element_slider_wheel, this)
dom_event_target_add_event_listener_without_options(this.dom_event_target(), ui_events_event_names_wheel, dom_idl_event_listener_create(realm, wheel_callback))
let mousedown_callback = html_input_element_native_callback(this, html_input_element_slider_mousedown, this)
dom_event_target_add_event_listener_without_options(this.dom_event_target(), ui_events_event_names_mousedown, dom_idl_event_listener_create(realm, mousedown_callback))
# mark: User interaction and the slider =========================================================
## The captures of user_interaction_did_change_input_value's element task: `[this, input_type, data]`.
struct HtmlInputElementUserInteractionTask:
var this: HtmlInputElement*
var input_type: ak.FlyString
var data: ak.Utf16String?
## user_interaction_did_change_input_value's element task: fire an input event.
func html_input_element_user_interaction_task(context: void*?):
let captures = (HtmlInputElementUserInteractionTask*)(context else trap("no captures"))
let this = captures.this
# https://w3c.github.io/uievents/#event-type-input
var input_event_init: UiEventsInputEventInit = ---
ui_events_input_event_init_init_fields(&input_event_init)
input_event_init.ui_event_init.event_init.bubbles = true
input_event_init.ui_event_init.event_init.composed = true
input_event_init.input_type = captures.input_type
input_event_init.data = captures.data
let input_event = ui_events_input_event_create_from_platform_event(html_input_element_realm(this), html_event_names_input, input_event_init)
# (InputEvent is opaque until phase 4; it is a DOM::Event first.)
_ = html_input_element_dispatch_event(this, (DomEvent*)input_event)
## Ported from HTMLInputElement.cpp:1459 Web::HTML::HTMLInputElement::user_interaction_did_change_input_value.
func html_input_element_user_interaction_did_change_input_value(this: HtmlInputElement*, input_type: ak.FlyString = ak.FlyString(), data: ak.Utf16String? = none):
# https://html.spec.whatwg.org/multipage/input.html#common-input-element-events
# For input elements without a defined input activation behavior, but to which these events apply,
# and for which the user interface involves both interactive manipulation and an explicit commit action,
# then when the user changes the element's value, the user agent must queue an element task on the user interaction task source
# given the input element to fire an event named input at the input element, with the bubbles and composed attributes initialized to true
let captures = new HtmlInputElementUserInteractionTask(this = this, input_type = input_type, data = data) else trap("out of memory")
_ = dom_element_queue_an_element_task(this.dom_element(), HtmlTaskSource.user_interaction, ak.Function0[unit](call = html_input_element_user_interaction_task, context = captures))
# and any time the user commits the change, the user agent must queue an element task on the user interaction task source given the input
# element to set its user validity to true and fire an event named change at the input element, with the bubbles attribute initialized to true.
# NOTE: This is done manually as needed
## Ported from HTMLInputElement.cpp:1481 Web::HTML::HTMLInputElement::update_slider_shadow_tree_elements.
func html_input_element_update_slider_shadow_tree_elements(this: HtmlInputElement*):
let value = html_input_element_convert_string_to_number_utf16_string(this, html_input_element_value_sanitization_algorithm(this, this.m_value)) else 0.0
let minimum = html_input_element_min(this) else trap("VERIFY: Optional::operator*")
let maximum = html_input_element_max(this) else trap("VERIFY: Optional::operator*")
let position = (value - minimum) / (maximum - minimum) * 100.0
if let slider_progress_element = this.m_slider_progress_element:
let width = html_string_formatted("{}%", [ak.arg_f64(position)])
css_style_properties_set_property_property_id(dom_element_style_for_bindings(slider_progress_element), css_data.PropertyId.width, ak.string_bytes_as_string_view(&width), ak.sv("")) else trap("MUST: set_property")
if let slider_thumb = this.m_slider_thumb:
let margin_left = html_string_formatted("{}%", [ak.arg_f64(position)])
css_style_properties_set_property_property_id(dom_element_style_for_bindings(slider_thumb), css_data.PropertyId.margin_left, ak.string_bytes_as_string_view(&margin_left), ak.sv("")) else trap("MUST: set_property")