Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 13:40:08 +01:00
Code Issues Projects Releases Packages Wiki Activity

Remove min/max functions from util::geometry. Use std::cmp instead.

Browse source
This commit is contained in:
Simon Sapin 2014-09-19 13:56:35 +01:00
parent 415bbaeb2e
commit 010d87b93e
10 changed files with 39 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

18
components/layout/block.rs
View file

@ -38,9 +38,9 @@ use gfx::display_list::{RootOfStackingContextLevel};
use gfx::render_task::RenderLayer;
use servo_msg::compositor_msg::{FixedPosition, LayerId, Scrollable};
use servo_util::geometry::Au;
use servo_util::geometry;
use servo_util::logical_geometry::WritingMode;
use servo_util::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize};
use std::cmp::{max, min};
use std::fmt;
use std::mem;
use style::computed_values::{LPA_Auto, LPA_Length, LPA_Percentage, LPN_Length, LPN_None};
@ -723,8 +723,8 @@ impl BlockFlow {
/// This is where we use the preferred inline-sizes and minimum inline-sizes
/// calculated in the bubble-inline-sizes traversal.
fn get_shrink_to_fit_inline_size(&self, available_inline_size: Au) -> Au {
geometry::min(self.base.intrinsic_inline_sizes.preferred_inline_size,
geometry::max(self.base.intrinsic_inline_sizes.minimum_inline_size, available_inline_size))
min(self.base.intrinsic_inline_sizes.preferred_inline_size,
max(self.base.intrinsic_inline_sizes.minimum_inline_size, available_inline_size))
}
/// Collect and update static y-offsets bubbled up by kids.
@ -1090,7 +1090,7 @@ impl BlockFlow {
// Intrinsic height should include floating descendants with a margin
// below the element's bottom edge (see CSS Section 10.6.7).
let content_block_size = geometry::max(
let content_block_size = max(
cur_b - block_start_offset,
floats.clearance(ClearBoth));
@ -1509,13 +1509,13 @@ impl Flow for BlockFlow {
if !fixed_width {
intrinsic_inline_sizes.minimum_inline_size =
geometry::max(intrinsic_inline_sizes.minimum_inline_size,
max(intrinsic_inline_sizes.minimum_inline_size,
child_base.intrinsic_inline_sizes.total_minimum_inline_size());
match float_kind {
float::none => {
intrinsic_inline_sizes.preferred_inline_size =
geometry::max(intrinsic_inline_sizes.preferred_inline_size,
max(intrinsic_inline_sizes.preferred_inline_size,
child_base.intrinsic_inline_sizes.total_preferred_inline_size());
}
float::left => {
@ -1533,13 +1533,13 @@ impl Flow for BlockFlow {
}
intrinsic_inline_sizes.preferred_inline_size =
geometry::max(intrinsic_inline_sizes.preferred_inline_size,
max(intrinsic_inline_sizes.preferred_inline_size,
left_float_width + right_float_width);
let fragment_intrinsic_inline_sizes = self.fragment.intrinsic_inline_sizes();
intrinsic_inline_sizes.minimum_inline_size = geometry::max(intrinsic_inline_sizes.minimum_inline_size,
intrinsic_inline_sizes.minimum_inline_size = max(intrinsic_inline_sizes.minimum_inline_size,
fragment_intrinsic_inline_sizes.minimum_inline_size);
intrinsic_inline_sizes.preferred_inline_size = geometry::max(intrinsic_inline_sizes.preferred_inline_size,
intrinsic_inline_sizes.preferred_inline_size = max(intrinsic_inline_sizes.preferred_inline_size,
fragment_intrinsic_inline_sizes.preferred_inline_size);
intrinsic_inline_sizes.surround_inline_size = fragment_intrinsic_inline_sizes.surround_inline_size;
self.base.intrinsic_inline_sizes = intrinsic_inline_sizes;

3
components/layout/floats.rs
View file

@ -2,9 +2,10 @@
* 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/. */
use servo_util::geometry::{Au, max, min};
use servo_util::geometry::Au;
use servo_util::logical_geometry::WritingMode;
use servo_util::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize};
use std::cmp::{max, min};
use std::i32;
use std::fmt;
use style::computed_values::float;

13
components/layout/fragment.rs
View file

@ -46,6 +46,7 @@ use servo_util::range::*;
use servo_util::namespace;
use servo_util::smallvec::SmallVec;
use servo_util::str::is_whitespace;
use std::cmp::{max, min};
use std::fmt;
use std::from_str::FromStr;
use std::mem;
@ -1165,17 +1166,17 @@ impl Fragment {
TableWrapperFragment => {}
InlineBlockFragment(ref mut info) => {
let block_flow = info.flow_ref.get_mut().as_block();
result.minimum_inline_size = geometry::max(result.minimum_inline_size,
result.minimum_inline_size = max(result.minimum_inline_size,
block_flow.base.intrinsic_inline_sizes.minimum_inline_size +
block_flow.base.intrinsic_inline_sizes.surround_inline_size);
result.preferred_inline_size = geometry::max(result.preferred_inline_size,
result.preferred_inline_size = max(result.preferred_inline_size,
block_flow.base.intrinsic_inline_sizes.preferred_inline_size +
block_flow.base.intrinsic_inline_sizes.surround_inline_size);
},
ImageFragment(ref mut image_fragment_info) => {
let image_inline_size = image_fragment_info.image_inline_size();
result.minimum_inline_size = geometry::max(result.minimum_inline_size, image_inline_size);
result.preferred_inline_size = geometry::max(result.preferred_inline_size, image_inline_size);
result.minimum_inline_size = max(result.minimum_inline_size, image_inline_size);
result.preferred_inline_size = max(result.preferred_inline_size, image_inline_size);
}
ScannedTextFragment(ref text_fragment_info) => {
let range = &text_fragment_info.range;
@ -1185,8 +1186,8 @@ impl Fragment {
// TODO: Account for soft wrap opportunities.
let max_line_inline_size = text_fragment_info.run.metrics_for_range(range).advance_width;
result.minimum_inline_size = geometry::max(result.minimum_inline_size, min_line_inline_size);
result.preferred_inline_size = geometry::max(result.preferred_inline_size, max_line_inline_size);
result.minimum_inline_size = max(result.minimum_inline_size, min_line_inline_size);
result.preferred_inline_size = max(result.preferred_inline_size, max_line_inline_size);
}
UnscannedTextFragment(..) => fail!("Unscanned text fragments should have been scanned by now!"),
}

4
components/layout/inline.rs
View file

@ -23,10 +23,10 @@ use gfx::font_context::FontContext;
use geom::Size2D;
use gfx::text::glyph::CharIndex;
use servo_util::geometry::Au;
use servo_util::geometry;
use servo_util::logical_geometry::{LogicalRect, LogicalSize};
use servo_util::range;
use servo_util::range::{EachIndex, Range, RangeIndex, IntRangeIndex};
use std::cmp::max;
use std::fmt;
use std::mem;
use std::num;
@ -928,7 +928,7 @@ impl Flow for InlineFlow {
let fragment_intrinsic_inline_sizes =
fragment.intrinsic_inline_sizes();
intrinsic_inline_sizes.minimum_inline_size = geometry::max(
intrinsic_inline_sizes.minimum_inline_size = max(
intrinsic_inline_sizes.minimum_inline_size,
fragment_intrinsic_inline_sizes.minimum_inline_size);
intrinsic_inline_sizes.preferred_inline_size =

6
components/layout/model.rs
View file

@ -13,8 +13,8 @@ use geom::SideOffsets2D;
use style::computed_values::{LPA_Auto, LPA_Length, LPA_Percentage, LP_Length, LP_Percentage};
use style::ComputedValues;
use servo_util::geometry::Au;
use servo_util::geometry;
use servo_util::logical_geometry::LogicalMargin;
use std::cmp::{max, min};
use std::fmt;
/// A collapsible margin. See CSS 2.1 § 8.3.1.
@ -50,8 +50,8 @@ impl AdjoiningMargins {
}
pub fn union(&mut self, other: AdjoiningMargins) {
self.most_positive = geometry::max(self.most_positive, other.most_positive);
self.most_negative = geometry::min(self.most_negative, other.most_negative)
self.most_positive = max(self.most_positive, other.most_positive);
self.most_negative = min(self.most_negative, other.most_negative)
}
pub fn collapse(&self) -> Au {

4
components/layout/table.rs
View file

@ -17,8 +17,8 @@ use table_wrapper::{TableLayout, FixedLayout, AutoLayout};
use wrapper::ThreadSafeLayoutNode;
use servo_util::geometry::Au;
use servo_util::geometry;
use servo_util::logical_geometry::LogicalRect;
use std::cmp::max;
use std::fmt;
use style::computed_values::table_layout;
@ -233,7 +233,7 @@ impl Flow for TableFlow {
let fragment_intrinsic_inline_sizes = self.block_flow.fragment.intrinsic_inline_sizes();
self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = min_inline_size;
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size =
geometry::max(min_inline_size, pref_inline_size);
max(min_inline_size, pref_inline_size);
self.block_flow.base.intrinsic_inline_sizes.surround_inline_size =
fragment_intrinsic_inline_sizes.surround_inline_size;
}

12
components/layout/table_row.rs
View file

@ -18,7 +18,7 @@ use model::{MaybeAuto, Specified, Auto};
use wrapper::ThreadSafeLayoutNode;
use servo_util::geometry::Au;
use servo_util::geometry;
use std::cmp::max;
use std::fmt;
/// A table formatting context.
@ -91,19 +91,19 @@ impl TableRowFlow {
let child_specified_block_size = MaybeAuto::from_style(child_fragment.style().content_block_size(),
Au::new(0)).specified_or_zero();
max_y =
geometry::max(max_y,
max(max_y,
child_specified_block_size + child_fragment.border_padding.block_start_end());
}
let child_node = flow::mut_base(kid);
child_node.position.start.b = cur_y;
max_y = geometry::max(max_y, child_node.position.size.block);
max_y = max(max_y, child_node.position.size.block);
}
let mut block_size = max_y;
// TODO: Percentage block-size
block_size = match MaybeAuto::from_style(self.block_flow.fragment.style().content_block_size(), Au(0)) {
Auto => block_size,
Specified(value) => geometry::max(value, block_size)
Specified(value) => max(value, block_size)
};
// cur_y = cur_y + block-size;
@ -188,8 +188,8 @@ impl Flow for TableRowFlow {
pref_inline_size = pref_inline_size + child_base.intrinsic_inline_sizes.preferred_inline_size;
}
self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = min_inline_size;
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = geometry::max(min_inline_size,
pref_inline_size);
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = max(
min_inline_size, pref_inline_size);
}
/// Recursively (top-down) determines the actual inline-size of child contexts and fragments. When called

6
components/layout/table_rowgroup.rs
View file

@ -17,7 +17,7 @@ use table::{InternalTable, TableFlow};
use wrapper::ThreadSafeLayoutNode;
use servo_util::geometry::Au;
use servo_util::geometry;
use std::cmp::max;
use std::fmt;
/// A table formatting context.
@ -169,8 +169,8 @@ impl Flow for TableRowGroupFlow {
}
self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = min_inline_size;
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = geometry::max(min_inline_size,
pref_inline_size);
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = max(
min_inline_size, pref_inline_size);
}
/// Recursively (top-down) determines the actual inline-size of child contexts and fragments. When

10
components/layout/table_wrapper.rs
View file

@ -17,7 +17,7 @@ use model::{Specified, Auto, specified};
use wrapper::ThreadSafeLayoutNode;
use servo_util::geometry::Au;
use servo_util::geometry;
use std::cmp::max;
use std::fmt;
use style::computed_values::table_layout;
@ -250,7 +250,7 @@ impl TableWrapper {
// Compare border-edge inline-sizes. Because fixed_cells_inline-size indicates content-inline-size,
// padding and border values are added to fixed_cells_inline-size.
computed_inline_size = geometry::max(
computed_inline_size = max(
fixed_cells_inline_size + padding_and_borders, computed_inline_size);
computed_inline_size
},
@ -276,7 +276,7 @@ impl TableWrapper {
// required by all columns. It will be distributed over the columns.
let (inline_size, extra_inline_size) = match input.computed_inline_size {
Auto => {
if input.available_inline_size > geometry::max(cols_max, cap_min) {
if input.available_inline_size > max(cols_max, cap_min) {
if cols_max > cap_min {
table_wrapper.col_inline_sizes = col_pref_inline_sizes.clone();
(cols_max, Au(0))
@ -288,7 +288,7 @@ impl TableWrapper {
table_wrapper.col_inline_sizes = col_min_inline_sizes.clone();
cols_min
} else {
geometry::max(input.available_inline_size, cap_min)
max(input.available_inline_size, cap_min)
};
(max, max - cols_min)
}
@ -298,7 +298,7 @@ impl TableWrapper {
table_wrapper.col_inline_sizes = col_min_inline_sizes.clone();
cols_min
} else {
geometry::max(inline_size, cap_min)
max(inline_size, cap_min)
};
(max, max - cols_min)
}

4
components/util/geometry.rs
View file

@ -134,10 +134,6 @@ impl Neg<Au> for Au {
}
}
#[inline]
pub fn min(x: Au, y: Au) -> Au { if x < y { x } else { y } }
#[inline]
pub fn max(x: Au, y: Au) -> Au { if x > y { x } else { y } }
impl NumCast for Au {
#[inline]