djkato/egui
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

spelling fixes

Browse source
This commit is contained in:
Emil Ernerfeldt 2020-08-26 22:54:57 +02:00
parent d41b7a6234
commit 98c9e9bb41
7 changed files with 25 additions and 155 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
egui/src/containers/area.rs
View file

@ -1,5 +1,5 @@
//! Area is a `Ui` that has no parent, it floats on the background.
//! It has no frame or own size. It is potentioally movable.
//! It has no frame or own size. It is potentially movable.
//! It is the foundation for windows and popups.
use std::{fmt::Debug, hash::Hash, sync::Arc};
@ -16,7 +16,7 @@ pub(crate) struct State {
/// Last know size. Used for catching clicks.
pub size: Vec2,
/// If false, clicks goes stright throught to what is behind us.
/// If false, clicks goes straight through to what is behind us.
/// Good for tooltips etc.
pub interactable: bool,

2
egui/src/containers/frame.rs
View file

@ -18,7 +18,7 @@ impl Frame {
margin: style.window_padding,
corner_radius: style.window.corner_radius,
fill: Some(style.background_fill),
outline: style.interact.inactive.rect_outline, // becauce we can resize windows
outline: style.interact.inactive.rect_outline, // because we can resize windows
}
}

4
egui/src/containers/resize.rs
View file

@ -44,7 +44,7 @@ impl Default for Resize {
}
impl Resize {
/// Assign an explicit and globablly unique id.
/// Assign an explicit and globally unique id.
pub fn id(mut self, id: Id) -> Self {
self.id = Some(id);
self
@ -169,7 +169,7 @@ impl Resize {
let mut content_clip_rect = inner_rect.expand(ui.style().clip_rect_margin);
// If we pull the resize handle to shrink, we want to TRY to shink it.
// If we pull the resize handle to shrink, we want to TRY to shrink it.
// After laying out the contents, we might be much bigger.
// In those cases we don't want the clip_rect to be smaller, because
// then we will clip the contents of the region even thought the result gets larger. This is simply ugly!

2
egui/src/containers/window.rs
View file

@ -406,7 +406,7 @@ fn resize_window(ctx: &Context, window_interaction: &WindowInteraction) -> Optio
rect.max.y = ctx.round_to_pixel(mouse_pos.y);
}
} else {
// movevement
// movement
rect = rect.translate(mouse_pos - ctx.input().mouse.press_origin?);
}

130
egui/src/movement_tracker.rs
View file

@ -1,130 +0,0 @@
use std::collections::VecDeque;
/// This struct tracks recent values of some time series.
/// This can be used for things like smoothed averages (for e.g. FPS)
/// or for smoothed velocity (e.g. mouse pointer speed).
/// All times are in seconds.
#[derive(Clone, Debug)]
pub struct MovementTracker<T> {
max_len: usize,
max_age: f64,
/// (time, value) pais
values: VecDeque<(f64, T)>,
}
impl<T> MovementTracker<T>
where
T: Copy,
{
pub fn new(max_len: usize, max_age: f64) -> Self {
Self {
max_len,
max_age,
values: Default::default(),
}
}
pub fn is_empty(&self) -> bool {
self.values.is_empty()
}
pub fn len(&self) -> usize {
self.values.len()
}
/// Amount of time contained from start to end in this `MovementTracker`
pub fn dt(&self) -> f32 {
if let (Some(front), Some(back)) = (self.values.front(), self.values.back()) {
(back.0 - front.0) as f32
} else {
0.0
}
}
pub fn values<'a>(&'a self) -> impl Iterator<Item = T> + 'a {
self.values.iter().map(|(_time, value)| *value)
}
pub fn clear(&mut self) {
self.values.clear()
}
/// Values must be added with a monotonically increasing time, or at least not decreasing.
pub fn add(&mut self, now: f64, value: T) {
if let Some((last_time, _)) = self.values.back() {
debug_assert!(now >= *last_time, "Time shouldn't go backwards");
}
self.values.push_back((now, value));
self.flush(now);
}
/// Mean time difference between values in this `MovementTracker`.
pub fn mean_time_interval(&self) -> Option<f32> {
if let (Some(first), Some(last)) = (self.values.front(), self.values.back()) {
let n = self.len();
if n >= 2 {
Some((last.0 - first.0) as f32 / ((n - 1) as f32))
} else {
None
}
} else {
None
}
}
/// Remove samples that are too old
pub fn flush(&mut self, now: f64) {
while self.values.len() > self.max_len {
self.values.pop_front();
}
while let Some((front_time, _)) = self.values.front() {
if *front_time < now - self.max_age {
self.values.pop_front();
} else {
break;
}
}
}
}
impl<T> MovementTracker<T>
where
T: Copy,
T: std::iter::Sum,
T: std::ops::Div<f32, Output = T>,
{
pub fn sum(&self) -> T {
self.values().sum()
}
pub fn average(&self) -> Option<T> {
let num = self.len();
if num > 0 {
Some(self.sum() / (num as f32))
} else {
None
}
}
}
impl<T, Vel> MovementTracker<T>
where
T: Copy,
T: std::ops::Sub<Output = Vel>,
Vel: std::ops::Div<f32, Output = Vel>,
{
/// Calculate a smooth velocity (per second) over the entire time span
pub fn velocity(&self) -> Option<Vel> {
if let (Some(first), Some(last)) = (self.values.front(), self.values.back()) {
let dt = (last.0 - first.0) as f32;
if dt > 0.0 {
Some((last.1 - first.1) / dt)
} else {
None
}
} else {
None
}
}
}

2
egui/src/style.rs
View file

@ -185,7 +185,7 @@ pub struct WidgetStyle {
/// like buttons, the box of the checkbox, etc.
pub rect_outline: Option<LineStyle>,
/// Button frames etdc
/// Button frames etc
pub corner_radius: f32,
}

36
egui/src/ui.rs
View file

@ -21,7 +21,7 @@ pub struct Ui {
/// but may overflow (which you will see in child_bounds).
/// Some widgets (like separator lines) will try to fill the full desired width of the ui.
/// If the desired size is zero, it is a signal that child widgets should be as small as possible.
/// If the desired size is initie, it is a signal that child widgets should take up as much room as they want.
/// If the desired size is infinite, it is a signal that child widgets should take up as much room as they want.
desired_rect: Rect, // TODO: rename as max_rect ?
/// Bounding box of all children.
@ -30,7 +30,7 @@ pub struct Ui {
/// You can think of this as the minimum size.
child_bounds: Rect, // TODO: rename as min_rect ?
/// Overide default style in this ui
/// Override default style in this ui
style: Style,
layout: Layout,
@ -164,16 +164,16 @@ impl Ui {
/// Screen-space position of the current bottom right corner of this Ui.
/// This may move when we add children that overflow our desired rectangle bounds.
/// This position may be at inifnity if the desired rect is initinite,
/// which mappens when a parent widget says "be as big as you want to be".
/// This position may be at infinity if the desired rect is infinite,
/// which happens when a parent widget says "be as big as you want to be".
pub fn bottom_right(&self) -> Pos2 {
// If a child doesn't fit in desired_rect, we have effectively expanded:
self.desired_rect.max.max(self.child_bounds.max)
}
/// Position and current size of the ui.
/// The size is the maximum of the origional (minimum/desired) size and
/// the size of the containted children.
/// The size is the maximum of the original (minimum/desired) size and
/// the size of the contained children.
pub fn rect(&self) -> Rect {
Rect::from_min_max(self.top_left(), self.bottom_right())
}
@ -239,8 +239,8 @@ impl Ui {
/// The available space at the moment, given the current cursor.
/// This how much more space we can take up without overflowing our parent.
/// Shrinks as widgets allocate space and the cursor moves.
/// A small rectangle should be intepreted as "as little as possible".
/// An infinite rectangle should be interpred as "as much as you want".
/// A small rectangle should be interpreted as "as little as possible".
/// An infinite rectangle should be interpreted as "as much as you want".
/// In most layouts the next widget will be put in the top left corner of this `Rect`.
pub fn available(&self) -> Rect {
self.layout.available(self.cursor, self.rect())
@ -292,7 +292,7 @@ impl Ui {
/// Ideally, all widgets should use this. TODO
/// Widgets can set an explicit id source (user picked, e.g. some loop index),
/// and a defualt id source (e.g. label).
/// and a default id source (e.g. label).
/// If they fail to be unique, a positional id will be used instead.
pub fn make_unique_child_id_full(
&mut self,
@ -313,7 +313,7 @@ impl Ui {
.register_unique_id(id, default_id_source.unwrap_or_default(), self.cursor)
}
/// Make an Id that is unique to this positon.
/// Make an Id that is unique to this position.
/// Can be used for widgets that do NOT persist state in Memory
/// but you still need to interact with (e.g. buttons, sliders).
pub fn make_position_id(&self) -> Id {
@ -437,7 +437,7 @@ impl Ui {
/// Ask to allocate a certain amount of space and return a Painter for that region.
///
/// You may get back a `Painter` with a smaller or larger size than what you desired,
/// depending on the avilable space and the current layout.
/// depending on the available space and the current layout.
pub fn allocate_canvas(&mut self, desired_size: Vec2) -> Painter {
let rect = self.allocate_space(desired_size);
self.painter_at(rect)
@ -482,17 +482,17 @@ impl Ui {
self.add(TextEdit::new(text))
}
/// Show a radio button. It is selected if `*curr_value == radio_value`.
/// If clicked, `radio_value` is assigned to `*curr_value`;
/// Show a radio button. It is selected if `*current_value == radio_value`.
/// If clicked, `radio_value` is assigned to `*current_value`;
pub fn radio_value<Value: PartialEq>(
&mut self,
text: impl Into<String>,
curr_value: &mut Value,
current_value: &mut Value,
radio_value: Value,
) -> GuiResponse {
let response = self.radio(text, *curr_value == radio_value);
let response = self.radio(text, *current_value == radio_value);
if response.clicked {
*curr_value = radio_value;
*current_value = radio_value;
}
response
}
@ -503,7 +503,7 @@ impl Ui {
}
}
/// # Addding Containers / Sub-uis:
/// # Adding Containers / Sub-uis:
impl Ui {
pub fn collapsing<R>(
&mut self,
@ -515,7 +515,7 @@ impl Ui {
/// Create a child ui at the current cursor.
/// `size` is the desired size.
/// Actual size may be much smaller if `avilable_size()` is not enough.
/// Actual size may be much smaller if `available_size()` is not enough.
/// Set `size` to `Vec::infinity()` to get as much space as possible.
/// Just because you ask for a lot of space does not mean you have to use it!
/// After `add_contents` is called the contents of `bounding_size`