Skip to content

/ webrender

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Remove overscroll code and api. #2629

Merged
merged 1 commit into from Apr 6, 2018
+23 −365
Merged

Remove overscroll code and api. #2629

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter...
Filter file types
Jump to…
Jump to file
Failed to load files.

Always

Just for now

Loading status checks…

Remove overscroll code and api. 

Fixes #2545.
Fixes #1762.
Fixes #1314.
  • Loading branch information
@gw3583
gw3583 committed Apr 6, 2018
commit c262d18283d5e715b6655df5f8b1652fb66d6656
2 webrender/examples/scrolling.rs
View file
Open in desktop
@@ -165,7 +165,6 @@ impl Example for App {
txn.scroll(
ScrollLocation::Delta(LayoutVector2D::new(offset.0, offset.1)),
self.cursor_position,
ScrollEventPhase::Start,
);
}
glutin::WindowEvent::CursorMoved { position: (x, y), .. } => {
@@ -181,7 +180,6 @@ impl Example for App {
txn.scroll(
ScrollLocation::Delta(LayoutVector2D::new(dx, dy)),
self.cursor_position,
ScrollEventPhase::Start,
);
}
glutin::WindowEvent::MouseInput { .. } => {
119 webrender/src/clip_scroll_node.rs
View file
Open in desktop
@@ -4,7 +4,7 @@

use api::{DevicePixelScale, ExternalScrollId, LayerPixel, LayerPoint, LayerRect, LayerSize};
use api::{LayerVector2D, LayoutTransform, LayoutVector2D, PipelineId, PropertyBinding};
use api::{ScrollClamping, ScrollEventPhase, ScrollLocation, ScrollSensitivity, StickyOffsetBounds};
use api::{ScrollClamping, ScrollLocation, ScrollSensitivity, StickyOffsetBounds};
use api::WorldPoint;
use clip::{ClipChain, ClipChainNode, ClipSourcesHandle, ClipStore, ClipWorkItem};
use clip_scroll_tree::{ClipChainIndex, ClipScrollNodeIndex, CoordinateSystemId};
@@ -15,16 +15,9 @@ use gpu_cache::GpuCache;
use gpu_types::{ClipScrollNodeIndex as GPUClipScrollNodeIndex, ClipScrollNodeData};
use resource_cache::ResourceCache;
use scene::SceneProperties;
use spring::{DAMPING, STIFFNESS, Spring};
use util::{LayerToWorldFastTransform, LayerFastTransform, LayoutFastTransform};
use util::{TransformedRectKind};

#[cfg(target_os = "macos")]
const CAN_OVERSCROLL: bool = true;

#[cfg(not(target_os = "macos"))]
const CAN_OVERSCROLL: bool = false;

#[derive(Debug)]
pub struct StickyFrameInfo {
pub margins: SideOffsets2D<Option<f32>>,
@@ -269,8 +262,6 @@ impl ClipScrollNode {
}

scrolling.offset = new_offset;
scrolling.bouncing_back = false;
scrolling.started_bouncing_back = false;
true
}

@@ -666,17 +657,13 @@ impl ClipScrollNode {
}


pub fn scroll(&mut self, scroll_location: ScrollLocation, phase: ScrollEventPhase) -> bool {
pub fn scroll(&mut self, scroll_location: ScrollLocation) -> bool {
let scrolling = match self.node_type {
NodeType::ScrollFrame(ref mut scrolling) => scrolling,
_ => return false,
};

if scrolling.started_bouncing_back && phase == ScrollEventPhase::Move(false) {
return false;
}

let mut delta = match scroll_location {
let delta = match scroll_location {
ScrollLocation::Delta(delta) => delta,
ScrollLocation::Start => {
if scrolling.offset.y.round() >= 0.0 {
@@ -699,56 +686,25 @@ impl ClipScrollNode {
}
};

let overscroll_amount = scrolling.overscroll_amount();
let overscrolling = CAN_OVERSCROLL && (overscroll_amount != LayerVector2D::zero());
if overscrolling {
if overscroll_amount.x != 0.0 {
delta.x /= overscroll_amount.x.abs()
}
if overscroll_amount.y != 0.0 {
delta.y /= overscroll_amount.y.abs()
}
}

let scrollable_width = scrolling.scrollable_size.width;
let scrollable_height = scrolling.scrollable_size.height;
let is_unscrollable = scrollable_width <= 0. && scrollable_height <= 0.;
let original_layer_scroll_offset = scrolling.offset;

if scrollable_width > 0. {
scrolling.offset.x = scrolling.offset.x + delta.x;
if is_unscrollable || !CAN_OVERSCROLL {
scrolling.offset.x = scrolling.offset.x.min(0.0).max(-scrollable_width).round();
}
scrolling.offset.x = (scrolling.offset.x + delta.x)
.min(0.0)
.max(-scrollable_width)
.round();
}

if scrollable_height > 0. {
scrolling.offset.y = scrolling.offset.y + delta.y;
if is_unscrollable || !CAN_OVERSCROLL {
scrolling.offset.y = scrolling.offset.y.min(0.0).max(-scrollable_height).round();
}
scrolling.offset.y = (scrolling.offset.y + delta.y)
.min(0.0)
.max(-scrollable_height)
.round();
}

if phase == ScrollEventPhase::Start || phase == ScrollEventPhase::Move(true) {
scrolling.started_bouncing_back = false
} else if overscrolling &&
((delta.x < 1.0 && delta.y < 1.0) || phase == ScrollEventPhase::End)
{
scrolling.started_bouncing_back = true;
scrolling.bouncing_back = true
}

if CAN_OVERSCROLL {
scrolling.stretch_overscroll_spring(overscroll_amount);
}

scrolling.offset != original_layer_scroll_offset || scrolling.started_bouncing_back
}

pub fn tick_scrolling_bounce_animation(&mut self) {
if let NodeType::ScrollFrame(ref mut scrolling) = self.node_type {
scrolling.tick_scrolling_bounce_animation();
}
scrolling.offset != original_layer_scroll_offset
}

pub fn ray_intersects_node(&self, cursor: &WorldPoint) -> bool {
@@ -781,13 +737,6 @@ impl ClipScrollNode {
}
}

pub fn is_overscrolling(&self) -> bool {
match self.node_type {
NodeType::ScrollFrame(ref state) => state.overscroll_amount() != LayerVector2D::zero(),
_ => false,
}
}

pub fn matches_external_id(&self, external_id: ExternalScrollId) -> bool {
match self.node_type {
NodeType::ScrollFrame(info) if info.external_id == Some(external_id) => true,
@@ -799,10 +748,6 @@ impl ClipScrollNode {
#[derive(Copy, Clone, Debug)]
pub struct ScrollFrameInfo {
pub offset: LayerVector2D,
pub spring: Spring,
pub started_bouncing_back: bool,
pub bouncing_back: bool,
pub should_handoff_scroll: bool,
pub scroll_sensitivity: ScrollSensitivity,

/// Amount that this ScrollFrame can scroll in both directions.
@@ -815,7 +760,7 @@ pub struct ScrollFrameInfo {

}

/// Manages scrolling offset, overscroll state, etc.
/// Manages scrolling offset.
impl ScrollFrameInfo {
pub fn new(
scroll_sensitivity: ScrollSensitivity,
@@ -824,10 +769,6 @@ impl ScrollFrameInfo {
) -> ScrollFrameInfo {
ScrollFrameInfo {
offset: LayerVector2D::zero(),
spring: Spring::at(LayerPoint::zero(), STIFFNESS, DAMPING),
started_bouncing_back: false,
bouncing_back: false,
should_handoff_scroll: false,
scroll_sensitivity,
scrollable_size,
external_id,
@@ -840,40 +781,6 @@ impl ScrollFrameInfo {
ScrollSensitivity::Script => false,
}
}

pub fn stretch_overscroll_spring(&mut self, overscroll_amount: LayerVector2D) {
let offset = self.offset.to_point();
self.spring
.coords(offset, offset, offset + overscroll_amount);
}

pub fn tick_scrolling_bounce_animation(&mut self) {
let finished = self.spring.animate();
self.offset = self.spring.current().to_vector();
if finished {
self.bouncing_back = false
}
}

pub fn overscroll_amount(&self) -> LayerVector2D {
let overscroll_x = if self.offset.x > 0.0 {
-self.offset.x
} else if self.offset.x < -self.scrollable_size.width {
-self.scrollable_size.width - self.offset.x
} else {
0.0
};

let overscroll_y = if self.offset.y > 0.0 {
-self.offset.y
} else if self.offset.y < -self.scrollable_size.height {
-self.scrollable_size.height - self.offset.y
} else {
0.0
};

LayerVector2D::new(overscroll_x, overscroll_y)
}
}

/// Contains information about reference frames.
93 webrender/src/clip_scroll_tree.rs
View file
Open in desktop
@@ -3,7 +3,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use api::{DeviceIntRect, DevicePixelScale, ExternalScrollId, LayerPoint, LayerRect, LayerVector2D};
use api::{PipelineId, ScrollClamping, ScrollEventPhase, ScrollLocation, ScrollNodeState};
use api::{PipelineId, ScrollClamping, ScrollLocation, ScrollNodeState};
use api::WorldPoint;
use clip::{ClipChain, ClipSourcesHandle, ClipStore};
use clip_scroll_node::{ClipScrollNode, NodeType, ScrollFrameInfo, StickyFrameInfo};
@@ -70,10 +70,6 @@ pub struct ClipScrollTree {

pub pending_scroll_offsets: FastHashMap<ExternalScrollId, (LayerPoint, ScrollClamping)>,

/// The ClipId of the currently scrolling node. Used to allow the same
/// node to scroll even if a touch operation leaves the boundaries of that node.
pub currently_scrolling_node_index: Option<ClipScrollNodeIndex>,

/// The current frame id, used for giving a unique id to all new dynamically
/// added frames and clips. The ClipScrollTree increments this by one every
/// time a new dynamic frame is created.
@@ -116,7 +112,6 @@ impl ClipScrollTree {
clip_chains_descriptors: Vec::new(),
clip_chains: vec![ClipChain::empty(&DeviceIntRect::zero())],
pending_scroll_offsets: FastHashMap::default(),
currently_scrolling_node_index: None,
current_new_node_item: 1,
pipelines_to_discard: FastHashSet::default(),
}
@@ -138,18 +133,6 @@ impl ClipScrollTree {
TOPMOST_SCROLL_NODE_INDEX
}

pub fn collect_nodes_bouncing_back(&self) -> FastHashSet<ClipScrollNodeIndex> {
let mut nodes_bouncing_back = FastHashSet::default();
for (index, node) in self.nodes.iter().enumerate() {
if let NodeType::ScrollFrame(ref scrolling) = node.node_type {
if scrolling.bouncing_back {
nodes_bouncing_back.insert(ClipScrollNodeIndex(index));
}
}
}
nodes_bouncing_back
}

fn find_scrolling_node_at_point_in_node(
&self,
cursor: &WorldPoint,
@@ -235,71 +218,13 @@ impl ClipScrollTree {
&mut self,
scroll_location: ScrollLocation,
cursor: WorldPoint,
phase: ScrollEventPhase,
) -> bool {
if self.nodes.is_empty() {
return false;
}

let node_index = match (
phase,
self.find_scrolling_node_at_point(&cursor),
self.currently_scrolling_node_index,
) {
(ScrollEventPhase::Start, scroll_node_at_point_index, _) => {
self.currently_scrolling_node_index = Some(scroll_node_at_point_index);
scroll_node_at_point_index
}
(_, scroll_node_at_point_index, Some(cached_node_index)) => {
match self.nodes.get(cached_node_index.0) {
Some(_) => cached_node_index,
None => {
self.currently_scrolling_node_index = Some(scroll_node_at_point_index);
scroll_node_at_point_index
}
}
}
(_, _, None) => return false,
};

let topmost_scroll_node_index = self.topmost_scroll_node_index();
let non_root_overscroll = if node_index != topmost_scroll_node_index {
self.nodes[node_index.0].is_overscrolling()
} else {
false
};

let mut switch_node = false;
{
let node = &mut self.nodes[node_index.0];
if let NodeType::ScrollFrame(ref mut scrolling) = node.node_type {
match phase {
ScrollEventPhase::Start => {
// if this is a new gesture, we do not switch node,
// however we do save the state of non_root_overscroll,
// for use in the subsequent Move phase.
scrolling.should_handoff_scroll = non_root_overscroll;
}
ScrollEventPhase::Move(_) => {
// Switch node if movement originated in a new gesture,
// from a non root node in overscroll.
switch_node = scrolling.should_handoff_scroll && non_root_overscroll
}
ScrollEventPhase::End => {
// clean-up when gesture ends.
scrolling.should_handoff_scroll = false;
}
}
}
}

let node_index = if switch_node {
topmost_scroll_node_index
} else {
node_index
};

self.nodes[node_index.0].scroll(scroll_location, phase)
let node_index = self.find_scrolling_node_at_point(&cursor);
self.nodes[node_index.0].scroll(scroll_location)
}

pub fn update_tree(
@@ -433,12 +358,6 @@ impl ClipScrollTree {
}
}

pub fn tick_scrolling_bounce_animations(&mut self) {
for node in &mut self.nodes {
node.tick_scrolling_bounce_animation()
}
}

pub fn finalize_and_apply_pending_scroll_offsets(&mut self, old_states: ScrollStates) {
for node in &mut self.nodes {
let external_id = match node.node_type {
@@ -529,12 +448,6 @@ impl ClipScrollTree {

pub fn discard_frame_state_for_pipeline(&mut self, pipeline_id: PipelineId) {
self.pipelines_to_discard.insert(pipeline_id);

if let Some(index) = self.currently_scrolling_node_index {
if self.nodes[index.0].pipeline_id == pipeline_id {
self.currently_scrolling_node_index = None;
}
}
}

fn print_node<T: PrintTreePrinter>(
5 webrender/src/internal_types.rs
View file
Open in desktop
@@ -4,7 +4,6 @@

use api::{DebugCommand, DeviceUintRect, DocumentId, ExternalImageData, ExternalImageId};
use api::ImageFormat;
use clip_scroll_tree::ClipScrollNodeIndex;
use device::TextureFilter;
use renderer::PipelineInfo;
use gpu_cache::GpuCacheUpdateList;
@@ -138,21 +137,17 @@ pub struct RenderedDocument {
/// been rendered, which is necessary for reftests.
/// - Pipelines that were removed from the scene.
pub pipeline_info: PipelineInfo,
/// The layers that are currently affected by the over-scrolling animation.
pub layers_bouncing_back: FastHashSet<ClipScrollNodeIndex>,

pub frame: tiling::Frame,
}

impl RenderedDocument {
pub fn new(
pipeline_info: PipelineInfo,
layers_bouncing_back: FastHashSet<ClipScrollNodeIndex>,
frame: tiling::Frame,
) -> Self {
RenderedDocument {
pipeline_info,
layers_bouncing_back,
frame,
}
}
ProTip! Use n and p to navigate between commits in a pull request.
You can’t perform that action at this time.