mirror of
https://github.com/servo/servo.git
synced 2025-08-03 12:40:06 +01:00
Auto merge of #25674 - pshaughn:selection, r=jdm
Selection DOM interface (but not actual UI selections) This is work towards #7492. I put new tests in the mozilla-specific directory rather than the main tree because I'm not sure how upstreamable they are; I'd like opinions on that point. This adds a new exposed interface, which I understand from tests/mozilla/interfaces.html is something requiring specific approval from someone allowed to give that approval. Things that aren't done here: - The spec doesn't describe what selection/script-and-style-elements.html wants, and what it wants seems to require some sort of layout query. - Actual UI interactions are not present at all; selection.rs has a few TODOs saying which methods I believe the eventual UI code should call for what actions, but there are a lot of fine points here that I don't know about. - I haven't touched Node; you can ask if a node's in the Selection's Range the same way you'd ask about any other Range, but there's not a faster path just for selection layout.
This commit is contained in:
commit
4f36472b6f
30 changed files with 812 additions and 8468 deletions
|
@ -79,6 +79,7 @@ use crate::dom::pagetransitionevent::PageTransitionEvent;
|
|||
use crate::dom::processinginstruction::ProcessingInstruction;
|
||||
use crate::dom::promise::Promise;
|
||||
use crate::dom::range::Range;
|
||||
use crate::dom::selection::Selection;
|
||||
use crate::dom::servoparser::ServoParser;
|
||||
use crate::dom::shadowroot::ShadowRoot;
|
||||
use crate::dom::storageevent::StorageEvent;
|
||||
|
@ -400,6 +401,8 @@ pub struct Document {
|
|||
/// https://html.spec.whatwg.org/multipage/#concept-document-csp-list
|
||||
#[ignore_malloc_size_of = "Defined in rust-content-security-policy"]
|
||||
csp_list: DomRefCell<Option<CspList>>,
|
||||
/// https://w3c.github.io/slection-api/#dfn-selection
|
||||
selection: MutNullableDom<Selection>,
|
||||
}
|
||||
|
||||
#[derive(JSTraceable, MallocSizeOf)]
|
||||
|
@ -2909,6 +2912,7 @@ impl Document {
|
|||
media_controls: DomRefCell::new(HashMap::new()),
|
||||
dirty_webgl_contexts: DomRefCell::new(HashMap::new()),
|
||||
csp_list: DomRefCell::new(None),
|
||||
selection: MutNullableDom::new(None),
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -4618,6 +4622,11 @@ impl DocumentMethods for Document {
|
|||
// TODO: https://github.com/servo/servo/issues/21936
|
||||
Node::replace_all(None, self.upcast::<Node>());
|
||||
|
||||
// Specs and tests are in a state of flux about whether
|
||||
// we want to clear the selection when we remove the contents;
|
||||
// WPT selection/Document-open.html wants us to not clear it
|
||||
// as of Feb 1 2020
|
||||
|
||||
// Step 12
|
||||
if self.is_fully_active() {
|
||||
let mut new_url = entry_responsible_document.url();
|
||||
|
@ -4790,6 +4799,15 @@ impl DocumentMethods for Document {
|
|||
None => Err(Error::InvalidAccess),
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-document-getselection
|
||||
fn GetSelection(&self) -> Option<DomRoot<Selection>> {
|
||||
if self.has_browsing_context {
|
||||
Some(self.selection.or_init(|| Selection::new(self)))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn update_with_current_time_ms(marker: &Cell<u64>) {
|
||||
|
|
|
@ -488,6 +488,8 @@ macro_rules! global_event_handlers(
|
|||
event_handler!(seeked, GetOnseeked, SetOnseeked);
|
||||
event_handler!(seeking, GetOnseeking, SetOnseeking);
|
||||
event_handler!(select, GetOnselect, SetOnselect);
|
||||
event_handler!(selectionchange, GetOnselectionchange, SetOnselectionchange);
|
||||
event_handler!(selectstart, GetOnselectstart, SetOnselectstart);
|
||||
event_handler!(show, GetOnshow, SetOnshow);
|
||||
event_handler!(stalled, GetOnstalled, SetOnstalled);
|
||||
event_handler!(submit, GetOnsubmit, SetOnsubmit);
|
||||
|
|
|
@ -477,6 +477,7 @@ pub mod rtcpeerconnectioniceevent;
|
|||
pub mod rtcsessiondescription;
|
||||
pub mod rtctrackevent;
|
||||
pub mod screen;
|
||||
pub mod selection;
|
||||
pub mod serviceworker;
|
||||
pub mod serviceworkercontainer;
|
||||
pub mod serviceworkerglobalscope;
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
||||
|
||||
use crate::dom::bindings::cell::DomRefCell;
|
||||
use crate::dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods;
|
||||
use crate::dom::bindings::codegen::Bindings::NodeBinding::NodeConstants;
|
||||
use crate::dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
|
||||
|
@ -24,6 +25,7 @@ use crate::dom::documentfragment::DocumentFragment;
|
|||
use crate::dom::element::Element;
|
||||
use crate::dom::htmlscriptelement::HTMLScriptElement;
|
||||
use crate::dom::node::{Node, ShadowIncluding, UnbindContext};
|
||||
use crate::dom::selection::Selection;
|
||||
use crate::dom::text::Text;
|
||||
use crate::dom::window::Window;
|
||||
use dom_struct::dom_struct;
|
||||
|
@ -37,6 +39,16 @@ pub struct Range {
|
|||
reflector_: Reflector,
|
||||
start: BoundaryPoint,
|
||||
end: BoundaryPoint,
|
||||
// A range that belongs to a Selection needs to know about it
|
||||
// so selectionchange can fire when the range changes.
|
||||
// A range shouldn't belong to more than one Selection at a time,
|
||||
// but from the spec as of Feb 1 2020 I can't rule out a corner case like:
|
||||
// * Select a range R in document A, from node X to Y
|
||||
// * Insert everything from X to Y into document B
|
||||
// * Set B's selection's range to R
|
||||
// which leaves R technically, and observably, associated with A even though
|
||||
// it will fail the same-root-node check on many of A's selection's methods.
|
||||
associated_selections: DomRefCell<Vec<Dom<Selection>>>,
|
||||
}
|
||||
|
||||
impl Range {
|
||||
|
@ -50,6 +62,7 @@ impl Range {
|
|||
reflector_: Reflector::new(),
|
||||
start: BoundaryPoint::new(start_container, start_offset),
|
||||
end: BoundaryPoint::new(end_container, end_offset),
|
||||
associated_selections: DomRefCell::new(vec![]),
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -163,6 +176,9 @@ impl Range {
|
|||
|
||||
// https://dom.spec.whatwg.org/#concept-range-bp-set
|
||||
fn set_start(&self, node: &Node, offset: u32) {
|
||||
if &self.start.node != node || self.start.offset.get() != offset {
|
||||
self.report_change();
|
||||
}
|
||||
if &self.start.node != node {
|
||||
if self.start.node == self.end.node {
|
||||
node.ranges().push(WeakRef::new(&self));
|
||||
|
@ -178,6 +194,9 @@ impl Range {
|
|||
|
||||
// https://dom.spec.whatwg.org/#concept-range-bp-set
|
||||
fn set_end(&self, node: &Node, offset: u32) {
|
||||
if &self.end.node != node || self.end.offset.get() != offset {
|
||||
self.report_change();
|
||||
}
|
||||
if &self.end.node != node {
|
||||
if self.end.node == self.start.node {
|
||||
node.ranges().push(WeakRef::new(&self));
|
||||
|
@ -228,6 +247,26 @@ impl Range {
|
|||
// Step 6.
|
||||
Ok(Ordering::Equal)
|
||||
}
|
||||
|
||||
pub fn associate_selection(&self, selection: &Selection) {
|
||||
let mut selections = self.associated_selections.borrow_mut();
|
||||
if !selections.iter().any(|s| &**s == selection) {
|
||||
selections.push(Dom::from_ref(selection));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn disassociate_selection(&self, selection: &Selection) {
|
||||
self.associated_selections
|
||||
.borrow_mut()
|
||||
.retain(|s| &**s != selection);
|
||||
}
|
||||
|
||||
fn report_change(&self) {
|
||||
self.associated_selections
|
||||
.borrow()
|
||||
.iter()
|
||||
.for_each(|s| s.queue_selectionchange_task());
|
||||
}
|
||||
}
|
||||
|
||||
impl RangeMethods for Range {
|
||||
|
@ -821,6 +860,9 @@ impl RangeMethods for Range {
|
|||
// Step 3.
|
||||
if start_node == end_node {
|
||||
if let Some(text) = start_node.downcast::<CharacterData>() {
|
||||
if end_offset > start_offset {
|
||||
self.report_change();
|
||||
}
|
||||
return text.ReplaceData(start_offset, end_offset - start_offset, DOMString::new());
|
||||
}
|
||||
}
|
||||
|
@ -1142,9 +1184,11 @@ impl WeakRangeVec {
|
|||
entry.remove();
|
||||
}
|
||||
if &range.start.node == child {
|
||||
range.report_change();
|
||||
range.start.set(context.parent, offset);
|
||||
}
|
||||
if &range.end.node == child {
|
||||
range.report_change();
|
||||
range.end.set(context.parent, offset);
|
||||
}
|
||||
});
|
||||
|
@ -1169,9 +1213,11 @@ impl WeakRangeVec {
|
|||
entry.remove();
|
||||
}
|
||||
if &range.start.node == node {
|
||||
range.report_change();
|
||||
range.start.set(sibling, range.StartOffset() + length);
|
||||
}
|
||||
if &range.end.node == node {
|
||||
range.report_change();
|
||||
range.end.set(sibling, range.EndOffset() + length);
|
||||
}
|
||||
});
|
||||
|
@ -1212,9 +1258,11 @@ impl WeakRangeVec {
|
|||
}
|
||||
|
||||
if move_start {
|
||||
range.report_change();
|
||||
range.start.set(child, new_offset);
|
||||
}
|
||||
if move_end {
|
||||
range.report_change();
|
||||
range.end.set(child, new_offset);
|
||||
}
|
||||
});
|
||||
|
@ -1273,9 +1321,11 @@ impl WeakRangeVec {
|
|||
}
|
||||
|
||||
if move_start {
|
||||
range.report_change();
|
||||
range.start.set(sibling, start_offset - offset);
|
||||
}
|
||||
if move_end {
|
||||
range.report_change();
|
||||
range.end.set(sibling, end_offset - offset);
|
||||
}
|
||||
});
|
||||
|
@ -1289,9 +1339,11 @@ impl WeakRangeVec {
|
|||
(*self.cell.get()).update(|entry| {
|
||||
let range = entry.root().unwrap();
|
||||
if &range.start.node == node && offset == range.StartOffset() {
|
||||
range.report_change();
|
||||
range.start.set_offset(offset + 1);
|
||||
}
|
||||
if &range.end.node == node && offset == range.EndOffset() {
|
||||
range.report_change();
|
||||
range.end.set_offset(offset + 1);
|
||||
}
|
||||
});
|
||||
|
@ -1304,10 +1356,12 @@ impl WeakRangeVec {
|
|||
let range = entry.root().unwrap();
|
||||
let start_offset = range.StartOffset();
|
||||
if &range.start.node == node && start_offset > offset {
|
||||
range.report_change();
|
||||
range.start.set_offset(f(start_offset));
|
||||
}
|
||||
let end_offset = range.EndOffset();
|
||||
if &range.end.node == node && end_offset > offset {
|
||||
range.report_change();
|
||||
range.end.set_offset(f(end_offset));
|
||||
}
|
||||
});
|
||||
|
|
515
components/script/dom/selection.rs
Normal file
515
components/script/dom/selection.rs
Normal file
|
@ -0,0 +1,515 @@
|
|||
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
||||
|
||||
use crate::dom::bindings::codegen::Bindings::NodeBinding::{GetRootNodeOptions, NodeMethods};
|
||||
use crate::dom::bindings::codegen::Bindings::RangeBinding::RangeMethods;
|
||||
use crate::dom::bindings::codegen::Bindings::SelectionBinding::{SelectionMethods, Wrap};
|
||||
use crate::dom::bindings::error::{Error, ErrorResult, Fallible};
|
||||
use crate::dom::bindings::inheritance::Castable;
|
||||
use crate::dom::bindings::refcounted::Trusted;
|
||||
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
|
||||
use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
|
||||
use crate::dom::bindings::str::DOMString;
|
||||
use crate::dom::document::Document;
|
||||
use crate::dom::eventtarget::EventTarget;
|
||||
use crate::dom::node::{window_from_node, Node};
|
||||
use crate::dom::range::Range;
|
||||
use crate::task_source::TaskSource;
|
||||
use dom_struct::dom_struct;
|
||||
use std::cell::Cell;
|
||||
|
||||
#[derive(Clone, Copy, JSTraceable, MallocSizeOf)]
|
||||
enum Direction {
|
||||
Forwards,
|
||||
Backwards,
|
||||
Directionless,
|
||||
}
|
||||
|
||||
#[dom_struct]
|
||||
pub struct Selection {
|
||||
reflector_: Reflector,
|
||||
document: Dom<Document>,
|
||||
range: MutNullableDom<Range>,
|
||||
direction: Cell<Direction>,
|
||||
task_queued: Cell<bool>,
|
||||
}
|
||||
|
||||
impl Selection {
|
||||
fn new_inherited(document: &Document) -> Selection {
|
||||
Selection {
|
||||
reflector_: Reflector::new(),
|
||||
document: Dom::from_ref(document),
|
||||
range: MutNullableDom::new(None),
|
||||
direction: Cell::new(Direction::Directionless),
|
||||
task_queued: Cell::new(false),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new(document: &Document) -> DomRoot<Selection> {
|
||||
reflect_dom_object(
|
||||
Box::new(Selection::new_inherited(document)),
|
||||
&*document.global(),
|
||||
Wrap,
|
||||
)
|
||||
}
|
||||
|
||||
fn set_range(&self, range: &Range) {
|
||||
// If we are setting to literally the same Range object
|
||||
// (not just the same positions), then there's nothing changing
|
||||
// and no task to queue.
|
||||
if let Some(existing) = self.range.get() {
|
||||
if &*existing == range {
|
||||
return;
|
||||
}
|
||||
}
|
||||
self.range.set(Some(range));
|
||||
range.associate_selection(self);
|
||||
self.queue_selectionchange_task();
|
||||
}
|
||||
|
||||
fn clear_range(&self) {
|
||||
// If we already don't have a a Range object, then there's
|
||||
// nothing changing and no task to queue.
|
||||
if let Some(range) = self.range.get() {
|
||||
range.disassociate_selection(self);
|
||||
self.range.set(None);
|
||||
self.queue_selectionchange_task();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn queue_selectionchange_task(&self) {
|
||||
if self.task_queued.get() {
|
||||
// Spec doesn't specify not to queue multiple tasks,
|
||||
// but it's much easier to code range operations if
|
||||
// change notifications within a method are idempotent.
|
||||
return;
|
||||
}
|
||||
let this = Trusted::new(self);
|
||||
let window = window_from_node(&*self.document);
|
||||
window
|
||||
.task_manager()
|
||||
.user_interaction_task_source() // w3c/selection-api#117
|
||||
.queue(
|
||||
task!(selectionchange_task_steps: move || {
|
||||
let this = this.root();
|
||||
this.task_queued.set(false);
|
||||
this.document.upcast::<EventTarget>().fire_event(atom!("selectionchange"));
|
||||
}),
|
||||
window.upcast(),
|
||||
)
|
||||
.expect("Couldn't queue selectionchange task!");
|
||||
self.task_queued.set(true);
|
||||
}
|
||||
|
||||
fn is_same_root(&self, node: &Node) -> bool {
|
||||
&*node.GetRootNode(&GetRootNodeOptions::empty()) == self.document.upcast::<Node>()
|
||||
}
|
||||
}
|
||||
|
||||
impl SelectionMethods for Selection {
|
||||
// https://w3c.github.io/selection-api/#dom-selection-anchornode
|
||||
fn GetAnchorNode(&self) -> Option<DomRoot<Node>> {
|
||||
if let Some(range) = self.range.get() {
|
||||
match self.direction.get() {
|
||||
Direction::Forwards => Some(range.StartContainer()),
|
||||
_ => Some(range.EndContainer()),
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-anchoroffset
|
||||
fn AnchorOffset(&self) -> u32 {
|
||||
if let Some(range) = self.range.get() {
|
||||
match self.direction.get() {
|
||||
Direction::Forwards => range.StartOffset(),
|
||||
_ => range.EndOffset(),
|
||||
}
|
||||
} else {
|
||||
0
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-focusnode
|
||||
fn GetFocusNode(&self) -> Option<DomRoot<Node>> {
|
||||
if let Some(range) = self.range.get() {
|
||||
match self.direction.get() {
|
||||
Direction::Forwards => Some(range.EndContainer()),
|
||||
_ => Some(range.StartContainer()),
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-focusoffset
|
||||
fn FocusOffset(&self) -> u32 {
|
||||
if let Some(range) = self.range.get() {
|
||||
match self.direction.get() {
|
||||
Direction::Forwards => range.EndOffset(),
|
||||
_ => range.StartOffset(),
|
||||
}
|
||||
} else {
|
||||
0
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-iscollapsed
|
||||
fn IsCollapsed(&self) -> bool {
|
||||
if let Some(range) = self.range.get() {
|
||||
range.Collapsed()
|
||||
} else {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-rangecount
|
||||
fn RangeCount(&self) -> u32 {
|
||||
if self.range.get().is_some() {
|
||||
1
|
||||
} else {
|
||||
0
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-type
|
||||
fn Type(&self) -> DOMString {
|
||||
if let Some(range) = self.range.get() {
|
||||
if range.Collapsed() {
|
||||
DOMString::from("Caret")
|
||||
} else {
|
||||
DOMString::from("Range")
|
||||
}
|
||||
} else {
|
||||
DOMString::from("None")
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-getrangeat
|
||||
fn GetRangeAt(&self, index: u32) -> Fallible<DomRoot<Range>> {
|
||||
if index != 0 {
|
||||
Err(Error::IndexSize)
|
||||
} else if let Some(range) = self.range.get() {
|
||||
Ok(DomRoot::from_ref(&range))
|
||||
} else {
|
||||
Err(Error::IndexSize)
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-addrange
|
||||
fn AddRange(&self, range: &Range) {
|
||||
// Step 1
|
||||
if !self.is_same_root(&*range.StartContainer()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Step 2
|
||||
if self.RangeCount() != 0 {
|
||||
return;
|
||||
}
|
||||
|
||||
// Step 3
|
||||
self.set_range(range);
|
||||
// Are we supposed to set Direction here? w3c/selection-api#116
|
||||
self.direction.set(Direction::Forwards);
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-removerange
|
||||
fn RemoveRange(&self, range: &Range) -> ErrorResult {
|
||||
if let Some(own_range) = self.range.get() {
|
||||
if &*own_range == range {
|
||||
self.clear_range();
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
Err(Error::NotFound)
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-removeallranges
|
||||
fn RemoveAllRanges(&self) {
|
||||
self.clear_range();
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-empty
|
||||
// TODO: When implementing actual selection UI, this may be the correct
|
||||
// method to call as the abandon-selection action
|
||||
fn Empty(&self) {
|
||||
self.clear_range();
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-collapse
|
||||
fn Collapse(&self, node: Option<&Node>, offset: u32) -> ErrorResult {
|
||||
if let Some(node) = node {
|
||||
if node.is_doctype() {
|
||||
// w3c/selection-api#118
|
||||
return Err(Error::InvalidNodeType);
|
||||
}
|
||||
if offset > node.len() {
|
||||
// Step 2
|
||||
return Err(Error::IndexSize);
|
||||
}
|
||||
|
||||
if !self.is_same_root(node) {
|
||||
// Step 3
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Steps 4-5
|
||||
let range = Range::new(&self.document, node, offset, node, offset);
|
||||
|
||||
// Step 6
|
||||
self.set_range(&range);
|
||||
// Are we supposed to set Direction here? w3c/selection-api#116
|
||||
//
|
||||
self.direction.set(Direction::Forwards);
|
||||
} else {
|
||||
// Step 1
|
||||
self.clear_range();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-setposition
|
||||
// TODO: When implementing actual selection UI, this may be the correct
|
||||
// method to call as the start-of-selection action, after a
|
||||
// selectstart event has fired and not been cancelled.
|
||||
fn SetPosition(&self, node: Option<&Node>, offset: u32) -> ErrorResult {
|
||||
self.Collapse(node, offset)
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-collapsetostart
|
||||
fn CollapseToStart(&self) -> ErrorResult {
|
||||
if let Some(range) = self.range.get() {
|
||||
self.Collapse(Some(&*range.StartContainer()), range.StartOffset())
|
||||
} else {
|
||||
Err(Error::InvalidState)
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-collapsetoend
|
||||
fn CollapseToEnd(&self) -> ErrorResult {
|
||||
if let Some(range) = self.range.get() {
|
||||
self.Collapse(Some(&*range.EndContainer()), range.EndOffset())
|
||||
} else {
|
||||
Err(Error::InvalidState)
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-extend
|
||||
// TODO: When implementing actual selection UI, this may be the correct
|
||||
// method to call as the continue-selection action
|
||||
fn Extend(&self, node: &Node, offset: u32) -> ErrorResult {
|
||||
if !self.is_same_root(node) {
|
||||
// Step 1
|
||||
return Ok(());
|
||||
}
|
||||
if let Some(range) = self.range.get() {
|
||||
if node.is_doctype() {
|
||||
// w3c/selection-api#118
|
||||
return Err(Error::InvalidNodeType);
|
||||
}
|
||||
|
||||
if offset > node.len() {
|
||||
// As with is_doctype, not explicit in selection spec steps here
|
||||
// but implied by which exceptions are thrown in WPT tests
|
||||
return Err(Error::IndexSize);
|
||||
}
|
||||
|
||||
// Step 4
|
||||
if !self.is_same_root(&*range.StartContainer()) {
|
||||
// Step 5, and its following 8 and 9
|
||||
self.set_range(&*Range::new(&self.document, node, offset, node, offset));
|
||||
self.direction.set(Direction::Forwards);
|
||||
} else {
|
||||
let old_anchor_node = &*self.GetAnchorNode().unwrap(); // has range, therefore has anchor node
|
||||
let old_anchor_offset = self.AnchorOffset();
|
||||
let is_old_anchor_before_or_equal = {
|
||||
if old_anchor_node == node {
|
||||
old_anchor_offset <= offset
|
||||
} else {
|
||||
old_anchor_node.is_before(node)
|
||||
}
|
||||
};
|
||||
if is_old_anchor_before_or_equal {
|
||||
// Step 6, and its following 8 and 9
|
||||
self.set_range(&*Range::new(
|
||||
&self.document,
|
||||
old_anchor_node,
|
||||
old_anchor_offset,
|
||||
node,
|
||||
offset,
|
||||
));
|
||||
self.direction.set(Direction::Forwards);
|
||||
} else {
|
||||
// Step 7, and its following 8 and 9
|
||||
self.set_range(&*Range::new(
|
||||
&self.document,
|
||||
node,
|
||||
offset,
|
||||
old_anchor_node,
|
||||
old_anchor_offset,
|
||||
));
|
||||
self.direction.set(Direction::Backwards);
|
||||
}
|
||||
};
|
||||
} else {
|
||||
// Step 2
|
||||
return Err(Error::InvalidState);
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-setbaseandextent
|
||||
fn SetBaseAndExtent(
|
||||
&self,
|
||||
anchor_node: &Node,
|
||||
anchor_offset: u32,
|
||||
focus_node: &Node,
|
||||
focus_offset: u32,
|
||||
) -> ErrorResult {
|
||||
// Step 1
|
||||
if anchor_node.is_doctype() || focus_node.is_doctype() {
|
||||
// w3c/selection-api#118
|
||||
return Err(Error::InvalidNodeType);
|
||||
}
|
||||
|
||||
if anchor_offset > anchor_node.len() || focus_offset > focus_node.len() {
|
||||
return Err(Error::IndexSize);
|
||||
}
|
||||
|
||||
// Step 2
|
||||
if !self.is_same_root(anchor_node) || !self.is_same_root(focus_node) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Steps 5-7
|
||||
let is_focus_before_anchor = {
|
||||
if anchor_node == focus_node {
|
||||
focus_offset < anchor_offset
|
||||
} else {
|
||||
focus_node.is_before(anchor_node)
|
||||
}
|
||||
};
|
||||
if is_focus_before_anchor {
|
||||
self.set_range(&*Range::new(
|
||||
&self.document,
|
||||
focus_node,
|
||||
focus_offset,
|
||||
anchor_node,
|
||||
anchor_offset,
|
||||
));
|
||||
self.direction.set(Direction::Backwards);
|
||||
} else {
|
||||
self.set_range(&*Range::new(
|
||||
&self.document,
|
||||
anchor_node,
|
||||
anchor_offset,
|
||||
focus_node,
|
||||
focus_offset,
|
||||
));
|
||||
self.direction.set(Direction::Forwards);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-selectallchildren
|
||||
fn SelectAllChildren(&self, node: &Node) -> ErrorResult {
|
||||
if node.is_doctype() {
|
||||
// w3c/selection-api#118
|
||||
return Err(Error::InvalidNodeType);
|
||||
}
|
||||
if !self.is_same_root(node) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Spec wording just says node length here, but WPT specifically
|
||||
// wants number of children (the main difference is that it's 0
|
||||
// for cdata).
|
||||
self.set_range(&*Range::new(
|
||||
&self.document,
|
||||
node,
|
||||
0,
|
||||
node,
|
||||
node.children_count(),
|
||||
));
|
||||
|
||||
self.direction.set(Direction::Forwards);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-deletecontents
|
||||
fn DeleteFromDocument(&self) -> ErrorResult {
|
||||
if let Some(range) = self.range.get() {
|
||||
// Since the range is changing, it should trigger a
|
||||
// selectionchange event as it would if if mutated any other way
|
||||
return range.DeleteContents();
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-containsnode
|
||||
fn ContainsNode(&self, node: &Node, allow_partial_containment: bool) -> bool {
|
||||
// TODO: Spec requires a "visually equivalent to" check, which is
|
||||
// probably up to a layout query. This is therefore not a full implementation.
|
||||
if !self.is_same_root(node) {
|
||||
return false;
|
||||
}
|
||||
if let Some(range) = self.range.get() {
|
||||
let start_node = &*range.StartContainer();
|
||||
if !self.is_same_root(start_node) {
|
||||
// node can't be contained in a range with a different root
|
||||
return false;
|
||||
}
|
||||
if allow_partial_containment {
|
||||
// Spec seems to be incorrect here, w3c/selection-api#116
|
||||
if node.is_before(start_node) {
|
||||
return false;
|
||||
}
|
||||
let end_node = &*range.EndContainer();
|
||||
if end_node.is_before(node) {
|
||||
return false;
|
||||
}
|
||||
if node == start_node {
|
||||
return range.StartOffset() < node.len();
|
||||
}
|
||||
if node == end_node {
|
||||
return range.EndOffset() > 0;
|
||||
}
|
||||
return true;
|
||||
} else {
|
||||
if node.is_before(start_node) {
|
||||
return false;
|
||||
}
|
||||
let end_node = &*range.EndContainer();
|
||||
if end_node.is_before(node) {
|
||||
return false;
|
||||
}
|
||||
if node == start_node {
|
||||
return range.StartOffset() == 0;
|
||||
}
|
||||
if node == end_node {
|
||||
return range.EndOffset() == node.len();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
// No range
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-selection-stringifier
|
||||
fn Stringifier(&self) -> DOMString {
|
||||
// The spec as of Jan 31 2020 just says
|
||||
// "See W3C bug 10583." for this method.
|
||||
// Stringifying the range seems at least approximately right
|
||||
// and passes the non-style-dependent case in the WPT tests.
|
||||
if let Some(range) = self.range.get() {
|
||||
range.Stringifier()
|
||||
} else {
|
||||
DOMString::from("")
|
||||
}
|
||||
}
|
||||
}
|
|
@ -214,6 +214,12 @@ partial interface Document {
|
|||
|
||||
Document includes DocumentOrShadowRoot;
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-document
|
||||
partial interface Document {
|
||||
Selection? getSelection();
|
||||
};
|
||||
|
||||
|
||||
// Servo internal API.
|
||||
partial interface Document {
|
||||
[Throws]
|
||||
|
|
|
@ -95,6 +95,12 @@ partial interface mixin GlobalEventHandlers {
|
|||
attribute EventHandler ontransitionend;
|
||||
};
|
||||
|
||||
// https://w3c.github.io/selection-api/#extensions-to-globaleventhandlers-interface
|
||||
partial interface mixin GlobalEventHandlers {
|
||||
attribute EventHandler onselectstart;
|
||||
attribute EventHandler onselectionchange;
|
||||
};
|
||||
|
||||
// https://html.spec.whatwg.org/multipage/#windoweventhandlers
|
||||
[Exposed=Window]
|
||||
interface mixin WindowEventHandlers {
|
||||
|
|
32
components/script/dom/webidls/Selection.webidl
Normal file
32
components/script/dom/webidls/Selection.webidl
Normal file
|
@ -0,0 +1,32 @@
|
|||
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
||||
|
||||
// https://w3c.github.io/selection-api/#selection-interface
|
||||
[Exposed=Window]
|
||||
interface Selection {
|
||||
readonly attribute Node? anchorNode;
|
||||
readonly attribute unsigned long anchorOffset;
|
||||
readonly attribute Node? focusNode;
|
||||
readonly attribute unsigned long focusOffset;
|
||||
readonly attribute boolean isCollapsed;
|
||||
readonly attribute unsigned long rangeCount;
|
||||
readonly attribute DOMString type;
|
||||
[Throws] Range getRangeAt(unsigned long index);
|
||||
void addRange(Range range);
|
||||
[Throws] void removeRange(Range range);
|
||||
void removeAllRanges();
|
||||
void empty();
|
||||
[Throws] void collapse(Node? node, optional unsigned long offset = 0);
|
||||
[Throws] void setPosition(Node? node, optional unsigned long offset = 0);
|
||||
[Throws] void collapseToStart();
|
||||
[Throws] void collapseToEnd();
|
||||
[Throws] void extend(Node node, optional unsigned long offset = 0);
|
||||
[Throws]
|
||||
void setBaseAndExtent(Node anchorNode, unsigned long anchorOffset, Node focusNode, unsigned long focusOffset);
|
||||
[Throws] void selectAllChildren(Node node);
|
||||
[CEReactions, Throws]
|
||||
void deleteFromDocument();
|
||||
boolean containsNode(Node node, optional boolean allowPartialContainment = false);
|
||||
stringifier DOMString ();
|
||||
};
|
|
@ -175,6 +175,12 @@ partial interface Window {
|
|||
readonly attribute unsigned long runningAnimationCount;
|
||||
};
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-document
|
||||
partial interface Window {
|
||||
Selection? getSelection();
|
||||
};
|
||||
|
||||
|
||||
dictionary WindowPostMessageOptions : PostMessageOptions {
|
||||
USVString targetOrigin = "/";
|
||||
};
|
||||
|
|
|
@ -47,6 +47,7 @@ use crate::dom::node::{document_from_node, from_untrusted_node_address, Node, No
|
|||
use crate::dom::performance::Performance;
|
||||
use crate::dom::promise::Promise;
|
||||
use crate::dom::screen::Screen;
|
||||
use crate::dom::selection::Selection;
|
||||
use crate::dom::storage::Storage;
|
||||
use crate::dom::testrunner::TestRunner;
|
||||
use crate::dom::webglrenderingcontext::WebGLCommandSender;
|
||||
|
@ -1322,6 +1323,11 @@ impl WindowMethods for Window {
|
|||
fn Origin(&self) -> USVString {
|
||||
USVString(self.origin().immutable().ascii_serialization())
|
||||
}
|
||||
|
||||
// https://w3c.github.io/selection-api/#dom-window-getselection
|
||||
fn GetSelection(&self) -> Option<DomRoot<Selection>> {
|
||||
self.document.get().and_then(|d| d.GetSelection())
|
||||
}
|
||||
}
|
||||
|
||||
impl Window {
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue