1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/* 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 http://mozilla.org/MPL/2.0/. */
//! The high-level interface from script to layout. Using this abstract interface helps reduce
/// coupling between these two components, and enables the DOM to be placed in a separate crate
/// from layout.
use dom::node::LayoutDataRef;
use geom::point::Point2D;
use geom::rect::Rect;
use script_traits::{ScriptControlChan, OpaqueScriptLayoutChannel, UntrustedNodeAddress};
use servo_msg::constellation_msg::WindowSizeData;
use servo_util::geometry::Au;
use std::any::{Any, AnyRefExt};
use std::comm::{channel, Receiver, Sender};
use std::owned::BoxAny;
use style::Stylesheet;
use url::Url;
pub use dom::node::TrustedNodeAddress;
/// Asynchronous messages that script can send to layout.
pub enum Msg {
/// Adds the given stylesheet to the document.
AddStylesheetMsg(Stylesheet),
/// Adds the given stylesheet to the document.
LoadStylesheetMsg(Url),
/// Requests a reflow.
ReflowMsg(Box<Reflow>),
/// Get an RPC interface.
GetRPCMsg(Sender<Box<LayoutRPC + Send>>),
/// Destroys layout data associated with a DOM node.
///
/// TODO(pcwalton): Maybe think about batching to avoid message traffic.
ReapLayoutDataMsg(LayoutDataRef),
/// Requests that the layout task enter a quiescent state in which no more messages are
/// accepted except `ExitMsg`. A response message will be sent on the supplied channel when
/// this happens.
PrepareToExitMsg(Sender<()>),
/// Requests that the layout task immediately shut down. There must be no more nodes left after
/// this, or layout will crash.
ExitNowMsg,
}
/// Synchronous messages that script can send to layout.
///
/// In general, you should use messages to talk to Layout. Use the RPC interface
/// if and only if the work is
///
/// 1) read-only with respect to LayoutTaskData,
/// 2) small,
// 3) and really needs to be fast.
pub trait LayoutRPC {
/// Requests the dimensions of the content box, as in the `getBoundingClientRect()` call.
fn content_box(&self, node: TrustedNodeAddress) -> ContentBoxResponse;
/// Requests the dimensions of all the content boxes, as in the `getClientRects()` call.
fn content_boxes(&self, node: TrustedNodeAddress) -> ContentBoxesResponse;
/// Requests the node containing the point of interest
fn hit_test(&self, node: TrustedNodeAddress, point: Point2D<f32>) -> Result<HitTestResponse, ()>;
fn mouse_over(&self, node: TrustedNodeAddress, point: Point2D<f32>) -> Result<MouseOverResponse, ()>;
}
pub struct ContentBoxResponse(pub Rect<Au>);
pub struct ContentBoxesResponse(pub Vec<Rect<Au>>);
pub struct HitTestResponse(pub UntrustedNodeAddress);
pub struct MouseOverResponse(pub Vec<UntrustedNodeAddress>);
/// Why we're doing reflow.
#[deriving(PartialEq, Show)]
pub enum ReflowGoal {
/// We're reflowing in order to send a display list to the screen.
ReflowForDisplay,
/// We're reflowing in order to satisfy a script query. No display list will be created.
ReflowForScriptQuery,
}
/// Information needed for a reflow.
pub struct Reflow {
/// The document node.
pub document_root: TrustedNodeAddress,
/// The goal of reflow: either to render to the screen or to flush layout info for script.
pub goal: ReflowGoal,
/// The URL of the page.
pub url: Url,
/// Is the current reflow of an iframe, as opposed to a root window?
pub iframe: bool,
/// The channel through which messages can be sent back to the script task.
pub script_chan: ScriptControlChan,
/// The current window size.
pub window_size: WindowSizeData,
/// The channel that we send a notification to.
pub script_join_chan: Sender<()>,
/// Unique identifier
pub id: uint
}
/// Encapsulates a channel to the layout task.
#[deriving(Clone)]
pub struct LayoutChan(pub Sender<Msg>);
impl LayoutChan {
pub fn new() -> (Receiver<Msg>, LayoutChan) {
let (chan, port) = channel();
(port, LayoutChan(chan))
}
}
/// A trait to manage opaque references to script<->layout channels without needing
/// to expose the message type to crates that don't need to know about them.
pub trait ScriptLayoutChan {
fn new(sender: Sender<Msg>, receiver: Receiver<Msg>) -> Self;
fn sender(&self) -> Sender<Msg>;
fn receiver(self) -> Receiver<Msg>;
}
impl ScriptLayoutChan for OpaqueScriptLayoutChannel {
fn new(sender: Sender<Msg>, receiver: Receiver<Msg>) -> OpaqueScriptLayoutChannel {
let inner = (box sender as Box<Any+Send>, box receiver as Box<Any+Send>);
OpaqueScriptLayoutChannel(inner)
}
fn sender(&self) -> Sender<Msg> {
let &OpaqueScriptLayoutChannel((ref sender, _)) = self;
(*sender.downcast_ref::<Sender<Msg>>().unwrap()).clone()
}
fn receiver(self) -> Receiver<Msg> {
let OpaqueScriptLayoutChannel((_, receiver)) = self;
*receiver.downcast::<Receiver<Msg>>().unwrap()
}
}
|
