482 lines
15 KiB
Rust
482 lines
15 KiB
Rust
use apps::get_beo_apps;
|
|
use femtovg::{
|
|
renderer::OpenGl, Align, Baseline, Canvas, Color, FontId, ImageId, Paint, Path, Renderer,
|
|
};
|
|
use instant::Instant;
|
|
use resource::resource;
|
|
use winit::{
|
|
event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
|
|
event_loop::{ControlFlow, EventLoop},
|
|
window::Window,
|
|
};
|
|
|
|
mod helpers;
|
|
use helpers::PerfGraph;
|
|
|
|
// XXX rename to smth else
|
|
struct Fonts {
|
|
sans: FontId,
|
|
bold: FontId,
|
|
app_title: Paint,
|
|
app_menu: Paint,
|
|
app_menu_selected: Paint,
|
|
}
|
|
|
|
fn main() {
|
|
helpers::start(1024, 768, "Text demo");
|
|
}
|
|
|
|
use glutin::prelude::*;
|
|
|
|
mod apps;
|
|
mod hid;
|
|
mod roundy_math;
|
|
mod ui;
|
|
|
|
enum UiEvent<'e> {
|
|
WinitEvent(winit::event::Event<'e, ()>),
|
|
HardwareEvent(evdev::InputEvent),
|
|
}
|
|
|
|
fn run(
|
|
mut canvas: Canvas<OpenGl>,
|
|
el: EventLoop<()>,
|
|
context: glutin::context::PossiblyCurrentContext,
|
|
surface: glutin::surface::Surface<glutin::surface::WindowSurface>,
|
|
window: Window,
|
|
) {
|
|
let font_bold = canvas
|
|
.add_font_mem(&resource!("assets/Roboto-Bold.ttf"))
|
|
.expect("Cannot add font");
|
|
let font_sans = canvas
|
|
.add_font_mem(&resource!("assets/Roboto-Regular.ttf"))
|
|
.expect("Cannot add font");
|
|
|
|
let mut app_title = Paint::color(Color::hex("FFFFFF"));
|
|
app_title.set_font(&[font_bold]);
|
|
app_title.set_text_baseline(Baseline::Top);
|
|
app_title.set_text_align(Align::Center);
|
|
app_title.set_font_size(20.);
|
|
|
|
let mut app_menu = Paint::color(Color::hex("F0F0FF"));
|
|
app_menu.set_font(&[font_sans]);
|
|
app_menu.set_text_baseline(Baseline::Top);
|
|
app_menu.set_text_align(Align::Center);
|
|
app_menu.set_font_size(14.);
|
|
let mut app_menu_selected = Paint::color(Color::hex("F0F0FF"));
|
|
app_menu_selected.set_font(&[font_bold]);
|
|
app_menu_selected.set_text_baseline(Baseline::Top);
|
|
app_menu_selected.set_text_align(Align::Center);
|
|
app_menu_selected.set_font_size(14.);
|
|
|
|
let fonts = Fonts {
|
|
sans: font_sans,
|
|
bold: font_bold,
|
|
app_title,
|
|
app_menu,
|
|
app_menu_selected,
|
|
};
|
|
|
|
let apps = get_beo_apps();
|
|
let mut beo = ui::BeoUi::new(apps);
|
|
|
|
let start = Instant::now();
|
|
let mut prevt = start;
|
|
|
|
let mut perf = PerfGraph::new();
|
|
|
|
let mut font_size = 18.0;
|
|
|
|
#[cfg(feature = "debug_inspector")]
|
|
let mut font_texture_to_show: Option<usize> = None;
|
|
|
|
let mut beo_device = hid::Beo5Device::new_autodiscover().expect("Couldn't find Beo5 device");
|
|
/*
|
|
loop {
|
|
let ev = beo_device.get_event_nonblocking();
|
|
}
|
|
*/
|
|
|
|
let mut t = 0;
|
|
|
|
el.run(move |event, _, control_flow| {
|
|
t += 1;
|
|
*control_flow = ControlFlow::Poll;
|
|
|
|
let hw_event = beo_device.get_event_nonblocking();
|
|
match hw_event {
|
|
Some(ev) => {
|
|
println!("HW Event: {:?}", ev);
|
|
beo.accept_event(ev);
|
|
}
|
|
None => {}
|
|
}
|
|
|
|
match event {
|
|
Event::LoopDestroyed => *control_flow = ControlFlow::Exit,
|
|
Event::WindowEvent { ref event, .. } => match event {
|
|
WindowEvent::Resized(physical_size) => {
|
|
surface.resize(
|
|
&context,
|
|
physical_size.width.try_into().unwrap(),
|
|
physical_size.height.try_into().unwrap(),
|
|
);
|
|
}
|
|
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
|
|
WindowEvent::KeyboardInput {
|
|
input:
|
|
KeyboardInput {
|
|
virtual_keycode: Some(keycode),
|
|
state: ElementState::Pressed,
|
|
..
|
|
},
|
|
..
|
|
} => {
|
|
if keycode == &VirtualKeyCode::Escape {
|
|
*control_flow = ControlFlow::Exit;
|
|
}
|
|
println!("INput {:?}", keycode);
|
|
//if *keycode == VirtualKeyCode::W {
|
|
// y -= 0.1;
|
|
//}
|
|
|
|
if *keycode == VirtualKeyCode::NumpadAdd || *keycode == VirtualKeyCode::B {
|
|
println!("Add");
|
|
font_size += 1.0;
|
|
}
|
|
|
|
if *keycode == VirtualKeyCode::NumpadSubtract {
|
|
println!("DEL");
|
|
font_size -= 1.0;
|
|
}
|
|
}
|
|
#[cfg(feature = "debug_inspector")]
|
|
WindowEvent::MouseInput {
|
|
device_id: _,
|
|
state: ElementState::Pressed,
|
|
..
|
|
} => {
|
|
let len = canvas.debug_inspector_get_font_textures().len();
|
|
let next = match font_texture_to_show {
|
|
None => 0,
|
|
Some(i) => i + 1,
|
|
};
|
|
font_texture_to_show = if next < len { Some(next) } else { None };
|
|
}
|
|
WindowEvent::MouseWheel {
|
|
device_id: _,
|
|
delta: winit::event::MouseScrollDelta::LineDelta(_, y),
|
|
..
|
|
} => {
|
|
println!("Scroll {:?}", y);
|
|
font_size += *y / 2.0;
|
|
font_size = font_size.max(2.0);
|
|
}
|
|
_ => {
|
|
println!("{:?}", event);
|
|
}
|
|
},
|
|
Event::RedrawRequested(_) => {
|
|
let dpi_factor = window.scale_factor();
|
|
let size = window.inner_size();
|
|
canvas.set_size(size.width, size.height, dpi_factor as f32);
|
|
canvas.clear_rect(0, 0, size.width, size.height, Color::rgbf(0., 0., 0.));
|
|
|
|
let elapsed = start.elapsed().as_secs_f32();
|
|
let now = Instant::now();
|
|
let dt = (now - prevt).as_secs_f32();
|
|
prevt = now;
|
|
|
|
perf.update(dt);
|
|
|
|
//draw_main_menu(&mut canvas, &fonts, &beo);
|
|
beo.draw(&mut canvas, &fonts);
|
|
|
|
let mut paint = Paint::color(Color::hex("B7410E"));
|
|
paint.set_font(&[fonts.bold]);
|
|
paint.set_text_baseline(Baseline::Top);
|
|
paint.set_text_align(Align::Right);
|
|
let _ = canvas.fill_text(size.width as f32 - 10.0, 10.0, format!("{t}"), &paint);
|
|
|
|
/*
|
|
draw_baselines(&mut canvas, &fonts, 5.0, 50.0, font_size);
|
|
draw_alignments(&mut canvas, &fonts, 120.0, 200.0, font_size);
|
|
//draw_paragraph(&mut canvas, &fonts, x, y, font_size, LOREM_TEXT);
|
|
draw_inc_size(&mut canvas, &fonts, 300.0, 10.0);
|
|
|
|
draw_complex(&mut canvas, 300.0, 340.0, font_size);
|
|
|
|
draw_stroked(&mut canvas, &fonts, size.width as f32 - 200.0, 100.0);
|
|
draw_gradient_fill(&mut canvas, &fonts, size.width as f32 - 200.0, 180.0);
|
|
draw_image_fill(&mut canvas, &fonts, size.width as f32 - 200.0, 260.0, image_id, elapsed);
|
|
|
|
let mut paint = Paint::color(Color::hex("B7410E"));
|
|
paint.set_font(&[fonts.bold]);
|
|
paint.set_text_baseline(Baseline::Top);
|
|
paint.set_text_align(Align::Right);
|
|
let _ = canvas.fill_text(
|
|
size.width as f32 - 10.0,
|
|
10.0,
|
|
format!("Scroll to increase / decrease font size. Current: {font_size}"),
|
|
&paint,
|
|
);
|
|
#[cfg(feature = "debug_inspector")]
|
|
let _ = canvas.fill_text(
|
|
size.width as f32 - 10.0,
|
|
24.0,
|
|
format!("Click to show font atlas texture. Current: {:?}", font_texture_to_show),
|
|
paint,
|
|
);
|
|
*/
|
|
|
|
// XXX Why the save/reset/restore ?
|
|
canvas.save();
|
|
canvas.reset();
|
|
perf.render(&mut canvas, 1024. - 220., 768. - 60.);
|
|
canvas.restore();
|
|
|
|
#[cfg(feature = "debug_inspector")]
|
|
if let Some(index) = font_texture_to_show {
|
|
canvas.save();
|
|
canvas.reset();
|
|
let textures = canvas.debug_inspector_get_font_textures();
|
|
if let Some(&id) = textures.get(index) {
|
|
canvas.debug_inspector_draw_image(id);
|
|
}
|
|
canvas.restore();
|
|
}
|
|
|
|
canvas.flush();
|
|
surface.swap_buffers(&context).unwrap();
|
|
}
|
|
Event::MainEventsCleared => window.request_redraw(),
|
|
_ => (),
|
|
}
|
|
});
|
|
}
|
|
|
|
fn draw_baselines<T: Renderer>(
|
|
canvas: &mut Canvas<T>,
|
|
fonts: &Fonts,
|
|
x: f32,
|
|
y: f32,
|
|
font_size: f32,
|
|
) {
|
|
let baselines = [
|
|
Baseline::Top,
|
|
Baseline::Middle,
|
|
Baseline::Alphabetic,
|
|
Baseline::Bottom,
|
|
];
|
|
|
|
let mut paint = Paint::color(Color::black());
|
|
paint.set_font(&[fonts.sans]);
|
|
paint.set_font_size(font_size);
|
|
|
|
let base_text = "AbcpKjgF".to_string();
|
|
|
|
for (i, baseline) in baselines.iter().enumerate() {
|
|
let y = y + i as f32 * 40.0;
|
|
|
|
let mut path = Path::new();
|
|
path.move_to(x, y + 0.5);
|
|
path.line_to(x + 250., y + 0.5);
|
|
canvas.stroke_path(&path, &Paint::color(Color::rgba(255, 32, 32, 128)));
|
|
|
|
paint.set_text_baseline(*baseline);
|
|
|
|
if let Ok(res) =
|
|
canvas.fill_text(x, y, format!("{base_text} Baseline::{baseline:?}"), &paint)
|
|
{
|
|
//let res = canvas.fill_text(10.0, y, format!("d النص العربي جميل جدا {:?}", baseline), &paint);
|
|
|
|
let mut path = Path::new();
|
|
path.rect(res.x, res.y, res.width(), res.height());
|
|
canvas.stroke_path(&path, &Paint::color(Color::rgba(100, 100, 100, 64)));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw_alignments<T: Renderer>(
|
|
canvas: &mut Canvas<T>,
|
|
fonts: &Fonts,
|
|
x: f32,
|
|
y: f32,
|
|
font_size: f32,
|
|
) {
|
|
let alignments = [Align::Left, Align::Center, Align::Right];
|
|
|
|
let mut path = Path::new();
|
|
path.move_to(x + 0.5, y - 20.);
|
|
path.line_to(x + 0.5, y + 80.);
|
|
canvas.stroke_path(&path, &Paint::color(Color::rgba(255, 32, 32, 128)));
|
|
|
|
let mut paint = Paint::color(Color::black());
|
|
paint.set_font(&[fonts.sans]);
|
|
paint.set_font_size(font_size);
|
|
|
|
for (i, alignment) in alignments.iter().enumerate() {
|
|
paint.set_text_align(*alignment);
|
|
|
|
if let Ok(res) = canvas.fill_text(
|
|
x,
|
|
y + i as f32 * 30.0,
|
|
format!("Align::{alignment:?}"),
|
|
&paint,
|
|
) {
|
|
let mut path = Path::new();
|
|
path.rect(res.x, res.y, res.width(), res.height());
|
|
canvas.stroke_path(&path, &Paint::color(Color::rgba(100, 100, 100, 64)));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw_paragraph<T: Renderer>(
|
|
canvas: &mut Canvas<T>,
|
|
fonts: &Fonts,
|
|
x: f32,
|
|
y: f32,
|
|
font_size: f32,
|
|
text: &str,
|
|
) {
|
|
let mut paint = Paint::color(Color::black());
|
|
paint.set_font(&[fonts.bold]);
|
|
//paint.set_text_align(Align::Right);
|
|
paint.set_font_size(font_size);
|
|
|
|
let font_metrics = canvas.measure_font(&paint).expect("Error measuring font");
|
|
|
|
let width = canvas.width() as f32;
|
|
let mut y = y;
|
|
|
|
let lines = canvas
|
|
.break_text_vec(width, text, &paint)
|
|
.expect("Error while breaking text");
|
|
|
|
for line_range in lines {
|
|
if let Ok(_res) = canvas.fill_text(x, y, &text[line_range], &paint) {
|
|
y += font_metrics.height();
|
|
}
|
|
}
|
|
|
|
// let mut start = 0;
|
|
|
|
// while start < text.len() {
|
|
// let substr = &text[start..];
|
|
|
|
// if let Ok(index) = canvas.break_text(width, substr, &paint) {
|
|
// if let Ok(res) = canvas.fill_text(x, y, &substr[0..index], &paint) {
|
|
// y += res.height;
|
|
// }
|
|
|
|
// start += &substr[0..index].len();
|
|
// } else {
|
|
// break;
|
|
// }
|
|
// }
|
|
}
|
|
|
|
fn draw_inc_size<T: Renderer>(canvas: &mut Canvas<T>, fonts: &Fonts, x: f32, y: f32) {
|
|
let mut cursor_y = y;
|
|
|
|
for i in 4..23 {
|
|
let mut paint = Paint::color(Color::black());
|
|
paint.set_font(&[fonts.sans]);
|
|
paint.set_font_size(i as f32);
|
|
|
|
let font_metrics = canvas.measure_font(&paint).expect("Error measuring font");
|
|
|
|
if let Ok(_res) = canvas.fill_text(
|
|
x,
|
|
cursor_y,
|
|
"The quick brown fox jumps over the lazy dog",
|
|
&paint,
|
|
) {
|
|
cursor_y += font_metrics.height();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw_stroked<T: Renderer>(canvas: &mut Canvas<T>, fonts: &Fonts, x: f32, y: f32) {
|
|
let mut paint = Paint::color(Color::rgba(0, 0, 0, 128));
|
|
paint.set_font(&[fonts.bold]);
|
|
paint.set_line_width(12.0);
|
|
paint.set_font_size(72.0);
|
|
let _ = canvas.stroke_text(x + 5.0, y + 5.0, "RUST", &paint);
|
|
|
|
paint.set_color(Color::black());
|
|
paint.set_line_width(10.0);
|
|
let _ = canvas.stroke_text(x, y, "RUST", &paint);
|
|
|
|
paint.set_line_width(6.0);
|
|
paint.set_color(Color::hex("#B7410E"));
|
|
let _ = canvas.stroke_text(x, y, "RUST", &paint);
|
|
|
|
paint.set_color(Color::white());
|
|
let _ = canvas.fill_text(x, y, "RUST", &paint);
|
|
}
|
|
|
|
fn draw_gradient_fill<T: Renderer>(canvas: &mut Canvas<T>, fonts: &Fonts, x: f32, y: f32) {
|
|
let mut paint = Paint::color(Color::rgba(0, 0, 0, 255));
|
|
paint.set_font(&[fonts.bold]);
|
|
paint.set_line_width(6.0);
|
|
paint.set_font_size(72.0);
|
|
let _ = canvas.stroke_text(x, y, "RUST", &paint);
|
|
|
|
let mut paint = Paint::linear_gradient(
|
|
x,
|
|
y - 60.0,
|
|
x,
|
|
y,
|
|
Color::rgba(225, 133, 82, 255),
|
|
Color::rgba(93, 55, 70, 255),
|
|
);
|
|
paint.set_font(&[fonts.bold]);
|
|
paint.set_font_size(72.0);
|
|
let _ = canvas.fill_text(x, y, "RUST", &paint);
|
|
}
|
|
|
|
fn draw_image_fill<T: Renderer>(
|
|
canvas: &mut Canvas<T>,
|
|
fonts: &Fonts,
|
|
x: f32,
|
|
y: f32,
|
|
image_id: ImageId,
|
|
t: f32,
|
|
) {
|
|
let mut paint = Paint::color(Color::hex("#7300AB"));
|
|
paint.set_line_width(3.0);
|
|
let mut path = Path::new();
|
|
path.move_to(x, y - 2.0);
|
|
path.line_to(x + 180.0, y - 2.0);
|
|
canvas.stroke_path(&path, &paint);
|
|
|
|
let text = "RUST";
|
|
|
|
let mut paint = Paint::color(Color::rgba(0, 0, 0, 128));
|
|
paint.set_font(&[fonts.bold]);
|
|
paint.set_line_width(4.0);
|
|
paint.set_font_size(72.0);
|
|
let _ = canvas.stroke_text(x, y, text, &paint);
|
|
|
|
let mut paint = Paint::image(image_id, x, y - t * 10.0, 120.0, 120.0, 0.0, 0.50);
|
|
//let mut paint = Paint::image(image_id, x + 50.0, y - t*10.0, 120.0, 120.0, t.sin() / 10.0, 0.70);
|
|
paint.set_font(&[fonts.bold]);
|
|
paint.set_font_size(72.0);
|
|
let _ = canvas.fill_text(x, y, text, &paint);
|
|
}
|
|
|
|
fn draw_complex<T: Renderer>(canvas: &mut Canvas<T>, x: f32, y: f32, font_size: f32) {
|
|
let mut paint = Paint::color(Color::rgb(34, 34, 34));
|
|
paint.set_font_size(font_size);
|
|
|
|
let _ = canvas.fill_text(
|
|
x,
|
|
y,
|
|
"Latin اللغة العربية Кирилица тест iiiiiiiiiiiiiiiiiiiiiiiiiiiii\nasdasd",
|
|
&paint,
|
|
);
|
|
//let _ = canvas.fill_text(x, y, "اللغة العربية", &paint);
|
|
//canvas.fill_text(x, y, "Traditionally, text is composed to create a readable, coherent, and visually satisfying", &paint);
|
|
}
|