me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Move ggez example to tour

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2019-09-05 07:23:03 +02:00
parent 3440ba3cb4
commit ced3ffc225
11 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

145
examples/tour/renderer/button.rs Normal file
View file

@ -0,0 +1,145 @@
use super::Renderer;
use ggez::graphics::{
self, Align, Color, DrawParam, Rect, Scale, Text, TextFragment, WHITE,
};
use iced::{button, MouseCursor};
const LEFT: Rect = Rect {
x: 0.0,
y: 34.0,
w: 6.0,
h: 49.0,
};
const BACKGROUND: Rect = Rect {
x: LEFT.w,
y: LEFT.y,
w: 1.0,
h: LEFT.h,
};
const RIGHT: Rect = Rect {
x: LEFT.h - LEFT.w,
y: LEFT.y,
w: LEFT.w,
h: LEFT.h,
};
impl button::Renderer for Renderer<'_> {
fn draw(
&mut self,
cursor_position: iced::Point,
mut bounds: iced::Rectangle,
state: &button::State,
label: &str,
class: button::Class,
) -> MouseCursor {
let mouse_over = bounds.contains(cursor_position);
let mut state_offset = 0.0;
if mouse_over {
if state.is_pressed() {
bounds.y += 4.0;
state_offset = RIGHT.x + RIGHT.w;
} else {
bounds.y -= 1.0;
}
}
let class_index = match class {
button::Class::Primary => 0,
button::Class::Secondary => 1,
button::Class::Positive => 2,
};
let width = self.spritesheet.width() as f32;
let height = self.spritesheet.height() as f32;
self.sprites.add(DrawParam {
src: Rect {
x: (LEFT.x + state_offset) / width,
y: (LEFT.y + class_index as f32 * LEFT.h) / height,
w: LEFT.w / width,
h: LEFT.h / height,
},
dest: ggez::mint::Point2 {
x: bounds.x,
y: bounds.y,
},
..DrawParam::default()
});
self.sprites.add(DrawParam {
src: Rect {
x: (BACKGROUND.x + state_offset) / width,
y: (BACKGROUND.y + class_index as f32 * BACKGROUND.h) / height,
w: BACKGROUND.w / width,
h: BACKGROUND.h / height,
},
dest: ggez::mint::Point2 {
x: bounds.x + LEFT.w,
y: bounds.y,
},
scale: ggez::mint::Vector2 {
x: bounds.width - LEFT.w - RIGHT.w,
y: 1.0,
},
..DrawParam::default()
});
self.sprites.add(DrawParam {
src: Rect {
x: (RIGHT.x + state_offset) / width,
y: (RIGHT.y + class_index as f32 * RIGHT.h) / height,
w: RIGHT.w / width,
h: RIGHT.h / height,
},
dest: ggez::mint::Point2 {
x: bounds.x + bounds.width - RIGHT.w,
y: bounds.y,
},
..DrawParam::default()
});
let mut text = Text::new(TextFragment {
text: String::from(label),
font: Some(self.font),
scale: Some(Scale { x: 20.0, y: 20.0 }),
..Default::default()
});
text.set_bounds(
ggez::mint::Point2 {
x: bounds.width,
y: bounds.height,
},
Align::Center,
);
graphics::queue_text(
self.context,
&text,
ggez::mint::Point2 {
x: bounds.x,
y: bounds.y + BACKGROUND.h / 4.0,
},
Some(if mouse_over {
WHITE
} else {
Color {
r: 0.9,
g: 0.9,
b: 0.9,
a: 1.0,
}
}),
);
if mouse_over {
MouseCursor::Pointer
} else {
MouseCursor::OutOfBounds
}
}
}

64
examples/tour/renderer/checkbox.rs Normal file
View file

@ -0,0 +1,64 @@
use super::Renderer;
use ggez::graphics::{DrawParam, Rect};
use iced::{checkbox, MouseCursor};
const SPRITE: Rect = Rect {
x: 98.0,
y: 0.0,
w: 28.0,
h: 28.0,
};
impl checkbox::Renderer for Renderer<'_> {
fn draw(
&mut self,
cursor_position: iced::Point,
bounds: iced::Rectangle,
text_bounds: iced::Rectangle,
is_checked: bool,
) -> MouseCursor {
let mouse_over = bounds.contains(cursor_position)
|| text_bounds.contains(cursor_position);
let width = self.spritesheet.width() as f32;
let height = self.spritesheet.height() as f32;
self.sprites.add(DrawParam {
src: Rect {
x: (SPRITE.x + (if mouse_over { SPRITE.w } else { 0.0 }))
/ width,
y: SPRITE.y / height,
w: SPRITE.w / width,
h: SPRITE.h / height,
},
dest: ggez::mint::Point2 {
x: bounds.x,
y: bounds.y,
},
..DrawParam::default()
});
if is_checked {
self.sprites.add(DrawParam {
src: Rect {
x: (SPRITE.x + SPRITE.w * 2.0) / width,
y: SPRITE.y / height,
w: SPRITE.w / width,
h: SPRITE.h / height,
},
dest: ggez::mint::Point2 {
x: bounds.x,
y: bounds.y,
},
..DrawParam::default()
});
}
if mouse_over {
MouseCursor::Pointer
} else {
MouseCursor::OutOfBounds
}
}
}

30
examples/tour/renderer/debugger.rs Normal file
View file

@ -0,0 +1,30 @@
use super::Renderer;
use ggez::graphics::{Color, DrawMode, MeshBuilder, Rect};
impl iced::renderer::Debugger for Renderer<'_> {
type Color = Color;
fn explain(&mut self, layout: &iced::Layout<'_>, color: Color) {
let bounds = layout.bounds();
let mut debug_mesh =
self.debug_mesh.take().unwrap_or(MeshBuilder::new());
debug_mesh.rectangle(
DrawMode::stroke(1.0),
Rect {
x: bounds.x,
y: bounds.y,
w: bounds.width,
h: bounds.height,
},
color,
);
self.debug_mesh = Some(debug_mesh);
for child in layout.children() {
self.explain(&child, color);
}
}
}

51
examples/tour/renderer/image.rs Normal file
View file

@ -0,0 +1,51 @@
use super::Renderer;
use ggez::{graphics, nalgebra};
use iced::image;
impl image::Renderer<graphics::Image> for Renderer<'_> {
fn node(
&self,
style: iced::Style,
image: &graphics::Image,
width: Option<u16>,
height: Option<u16>,
_source: Option<iced::Rectangle<u16>>,
) -> iced::Node {
let aspect_ratio = image.width() as f32 / image.height() as f32;
let style = match (width, height) {
(Some(width), Some(height)) => style.width(width).height(height),
(Some(width), None) => style
.width(width)
.height((width as f32 / aspect_ratio).round() as u16),
(None, Some(height)) => style
.height(height)
.width((height as f32 * aspect_ratio).round() as u16),
(None, None) => style.width(image.width()).height(image.height()),
};
iced::Node::new(style)
}
fn draw(
&mut self,
image: &graphics::Image,
bounds: iced::Rectangle,
_source: Option<iced::Rectangle<u16>>,
) {
// We should probably use batches to draw images efficiently and keep
// draw side-effect free, but this is good enough for the example.
graphics::draw(
self.context,
image,
graphics::DrawParam::new()
.dest(nalgebra::Point2::new(bounds.x, bounds.y))
.scale(nalgebra::Vector2::new(
bounds.width / image.width() as f32,
bounds.height / image.height() as f32,
)),
)
.expect("Draw image");
}
}

63
examples/tour/renderer/radio.rs Normal file
View file

@ -0,0 +1,63 @@
use super::Renderer;
use ggez::graphics::{DrawParam, Rect};
use iced::{radio, MouseCursor, Point, Rectangle};
const SPRITE: Rect = Rect {
x: 98.0,
y: 28.0,
w: 28.0,
h: 28.0,
};
impl radio::Renderer for Renderer<'_> {
fn draw(
&mut self,
cursor_position: Point,
bounds: Rectangle,
bounds_with_label: Rectangle,
is_selected: bool,
) -> MouseCursor {
let mouse_over = bounds_with_label.contains(cursor_position);
let width = self.spritesheet.width() as f32;
let height = self.spritesheet.height() as f32;
self.sprites.add(DrawParam {
src: Rect {
x: (SPRITE.x + (if mouse_over { SPRITE.w } else { 0.0 }))
/ width,
y: SPRITE.y / height,
w: SPRITE.w / width,
h: SPRITE.h / height,
},
dest: ggez::mint::Point2 {
x: bounds.x,
y: bounds.y,
},
..DrawParam::default()
});
if is_selected {
self.sprites.add(DrawParam {
src: Rect {
x: (SPRITE.x + SPRITE.w * 2.0) / width,
y: SPRITE.y / height,
w: SPRITE.w / width,
h: SPRITE.h / height,
},
dest: ggez::mint::Point2 {
x: bounds.x,
y: bounds.y,
},
..DrawParam::default()
});
}
if mouse_over {
MouseCursor::Pointer
} else {
MouseCursor::OutOfBounds
}
}
}

82
examples/tour/renderer/slider.rs Normal file
View file

@ -0,0 +1,82 @@
use super::Renderer;
use ggez::graphics::{DrawParam, Rect};
use iced::{slider, MouseCursor, Point, Rectangle};
use std::ops::RangeInclusive;
const RAIL: Rect = Rect {
x: 98.0,
y: 56.0,
w: 1.0,
h: 4.0,
};
const MARKER: Rect = Rect {
x: RAIL.x + 28.0,
y: RAIL.y,
w: 16.0,
h: 24.0,
};
impl slider::Renderer for Renderer<'_> {
fn draw(
&mut self,
cursor_position: Point,
bounds: Rectangle,
state: &slider::State,
range: RangeInclusive<f32>,
value: f32,
) -> MouseCursor {
let width = self.spritesheet.width() as f32;
let height = self.spritesheet.height() as f32;
self.sprites.add(DrawParam {
src: Rect {
x: RAIL.x / width,
y: RAIL.y / height,
w: RAIL.w / width,
h: RAIL.h / height,
},
dest: ggez::mint::Point2 {
x: bounds.x + MARKER.w as f32 / 2.0,
y: bounds.y + 12.5,
},
scale: ggez::mint::Vector2 {
x: bounds.width - MARKER.w as f32,
y: 1.0,
},
..DrawParam::default()
});
let (range_start, range_end) = range.into_inner();
let marker_offset = (bounds.width - MARKER.w as f32)
* ((value - range_start) / (range_end - range_start).max(1.0));
let mouse_over = bounds.contains(cursor_position);
let is_active = state.is_dragging() || mouse_over;
self.sprites.add(DrawParam {
src: Rect {
x: (MARKER.x + (if is_active { MARKER.w } else { 0.0 }))
/ width,
y: MARKER.y / height,
w: MARKER.w / width,
h: MARKER.h / height,
},
dest: ggez::mint::Point2 {
x: bounds.x + marker_offset.round(),
y: bounds.y + (if state.is_dragging() { 2.0 } else { 0.0 }),
},
..DrawParam::default()
});
if state.is_dragging() {
MouseCursor::Grabbing
} else if mouse_over {
MouseCursor::Grab
} else {
MouseCursor::OutOfBounds
}
}
}

118
examples/tour/renderer/text.rs Normal file
View file

@ -0,0 +1,118 @@
use super::Renderer;
use ggez::graphics::{self, mint, Align, Color, Scale, Text, TextFragment};
use iced::text;
use std::cell::RefCell;
use std::f32;
impl text::Renderer<Color> for Renderer<'_> {
fn node(
&self,
style: iced::Style,
content: &str,
size: Option<u16>,
) -> iced::Node {
let font = self.font;
let font_cache = graphics::font_cache(self.context);
let content = String::from(content);
// TODO: Investigate why stretch tries to measure this MANY times
// with every ancestor's bounds.
// Bug? Using the library wrong? I should probably open an issue on
// the stretch repository.
// I noticed that the first measure is the one that matters in
// practice. Here, we use a RefCell to store the cached measurement.
let measure = RefCell::new(None);
let size = size.map(f32::from).unwrap_or(self.font_size);
iced::Node::with_measure(style, move |bounds| {
let mut measure = measure.borrow_mut();
if measure.is_none() {
let bounds = (
match bounds.width {
iced::Number::Undefined => f32::INFINITY,
iced::Number::Defined(w) => w,
},
match bounds.height {
iced::Number::Undefined => f32::INFINITY,
iced::Number::Defined(h) => h,
},
);
let mut text = Text::new(TextFragment {
text: content.clone(),
font: Some(font),
scale: Some(Scale { x: size, y: size }),
..Default::default()
});
text.set_bounds(
mint::Point2 {
x: bounds.0,
y: bounds.1,
},
Align::Left,
);
let (width, height) = font_cache.dimensions(&text);
let size = iced::Size {
width: width as f32,
height: height as f32,
};
// If the text has no width boundary we avoid caching as the
// layout engine may just be measuring text in a row.
if bounds.0 == f32::INFINITY {
return size;
} else {
*measure = Some(size);
}
}
measure.unwrap()
})
}
fn draw(
&mut self,
bounds: iced::Rectangle,
content: &str,
size: Option<u16>,
color: Option<Color>,
horizontal_alignment: text::HorizontalAlignment,
_vertical_alignment: text::VerticalAlignment,
) {
let size = size.map(f32::from).unwrap_or(self.font_size);
let mut text = Text::new(TextFragment {
text: String::from(content),
font: Some(self.font),
scale: Some(Scale { x: size, y: size }),
..Default::default()
});
text.set_bounds(
mint::Point2 {
x: bounds.width,
y: bounds.height,
},
match horizontal_alignment {
text::HorizontalAlignment::Left => graphics::Align::Left,
text::HorizontalAlignment::Center => graphics::Align::Center,
text::HorizontalAlignment::Right => graphics::Align::Right,
},
);
graphics::queue_text(
self.context,
&text,
mint::Point2 {
x: bounds.x,
y: bounds.y,
},
color.or(Some(graphics::BLACK)),
);
}
}