abstreet/ezgui/src/canvas.rs

237 lines
7.3 KiB
Rust
Raw Normal View History

// Copyright 2018 Google LLC, licensed under http://www.apache.org/licenses/LICENSE-2.0
use crate::{text, GfxCtx, ScreenPt, Text, UserInput};
use geom::{Bounds, Pt2D};
use graphics::Transformed;
use opengl_graphics::{Filter, GlyphCache, TextureSettings};
use piston::window::Size;
use std::cell::RefCell;
const ZOOM_SPEED: f64 = 0.1;
pub struct Canvas {
// All of these f64's are in screen-space, so do NOT use Pt2D.
// Public for saving/loading... should probably do better
pub cam_x: f64,
pub cam_y: f64,
pub cam_zoom: f64,
cursor_x: f64,
cursor_y: f64,
left_mouse_drag_from: Option<ScreenPt>,
2018-07-06 20:02:01 +03:00
pub window_size: Size,
glyphs: RefCell<GlyphCache<'static>>,
}
impl Canvas {
2018-09-10 03:10:34 +03:00
pub fn new() -> Canvas {
let texture_settings = TextureSettings::new().filter(Filter::Nearest);
// TODO We could also preload everything and not need the RefCell.
let glyphs = RefCell::new(
GlyphCache::new(
// TODO don't assume this exists!
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
(),
texture_settings,
)
.expect("Could not load font"),
);
Canvas {
cam_x: 0.0,
cam_y: 0.0,
cam_zoom: 1.0,
cursor_x: 0.0,
cursor_y: 0.0,
left_mouse_drag_from: None,
2018-09-10 03:10:34 +03:00
window_size: Size {
width: 0,
height: 0,
},
glyphs,
}
}
pub fn is_dragging(&self) -> bool {
self.left_mouse_drag_from.is_some()
}
2018-10-06 01:44:12 +03:00
pub fn handle_event(&mut self, input: &mut UserInput) {
if let Some(pt) = input.get_moved_mouse() {
self.cursor_x = pt.x;
self.cursor_y = pt.y;
if let Some(click) = self.left_mouse_drag_from {
self.cam_x += click.x - pt.x;
self.cam_y += click.y - pt.y;
self.left_mouse_drag_from = Some(pt);
}
}
if input.left_mouse_button_pressed() {
self.left_mouse_drag_from = Some(self.get_cursor_in_screen_space());
}
if input.left_mouse_button_released() {
self.left_mouse_drag_from = None;
}
if let Some(scroll) = input.get_mouse_scroll() {
// Zoom slower at low zooms, faster at high.
2018-10-06 01:44:12 +03:00
let delta = scroll * ZOOM_SPEED * self.cam_zoom;
self.zoom_towards_mouse(delta);
}
}
pub(crate) fn start_drawing(&mut self, g: &mut GfxCtx, window_size: Size) {
2018-07-06 20:02:01 +03:00
self.window_size = window_size;
2018-09-16 02:54:00 +03:00
g.ctx = g
.orig_ctx
.trans(-self.cam_x, -self.cam_y)
.zoom(self.cam_zoom)
}
2018-09-28 18:01:15 +03:00
pub fn draw_mouse_tooltip(&self, g: &mut GfxCtx, txt: Text) {
let glyphs = &mut self.glyphs.borrow_mut();
let (width, height) = txt.dims(glyphs);
let x1 = self.cursor_x - (width / 2.0);
let y1 = self.cursor_y - (height / 2.0);
text::draw_text_bubble(g, glyphs, ScreenPt::new(x1, y1), txt);
}
pub fn draw_text_at(&self, g: &mut GfxCtx, txt: Text, map_pt: Pt2D) {
let glyphs = &mut self.glyphs.borrow_mut();
let (width, height) = txt.dims(glyphs);
let pt = self.map_to_screen(map_pt);
text::draw_text_bubble(
g,
glyphs,
ScreenPt::new(pt.x - (width / 2.0), pt.y - (height / 2.0)),
txt,
);
}
2018-12-17 07:01:47 +03:00
pub fn draw_text_at_topleft(&self, g: &mut GfxCtx, txt: Text, pt: Pt2D) {
text::draw_text_bubble(
g,
&mut self.glyphs.borrow_mut(),
self.map_to_screen(pt),
txt,
);
2018-12-17 07:01:47 +03:00
}
pub fn draw_text_at_screenspace_topleft(&self, g: &mut GfxCtx, txt: Text, pt: ScreenPt) {
text::draw_text_bubble(g, &mut self.glyphs.borrow_mut(), pt, txt);
2018-12-04 22:18:52 +03:00
}
2018-09-28 17:52:36 +03:00
pub fn draw_text(
&self,
g: &mut GfxCtx,
2018-09-28 18:01:15 +03:00
txt: Text,
2018-09-28 17:52:36 +03:00
(horiz, vert): (HorizontalAlignment, VerticalAlignment),
) {
2018-09-28 18:01:15 +03:00
if txt.is_empty() {
return;
}
let glyphs = &mut self.glyphs.borrow_mut();
let (width, height) = txt.dims(glyphs);
2018-09-28 17:52:36 +03:00
let x1 = match horiz {
HorizontalAlignment::Left => 0.0,
HorizontalAlignment::Center => (f64::from(self.window_size.width) - width) / 2.0,
HorizontalAlignment::Right => f64::from(self.window_size.width) - width,
};
let y1 = match vert {
VerticalAlignment::Top => 0.0,
VerticalAlignment::Center => (f64::from(self.window_size.height) - height) / 2.0,
VerticalAlignment::Bottom => f64::from(self.window_size.height) - height,
};
text::draw_text_bubble(g, glyphs, ScreenPt::new(x1, y1), txt);
}
pub(crate) fn text_dims(&self, txt: &Text) -> (f64, f64) {
txt.dims(&mut self.glyphs.borrow_mut())
}
fn zoom_towards_mouse(&mut self, delta_zoom: f64) {
let old_zoom = self.cam_zoom;
self.cam_zoom += delta_zoom;
if self.cam_zoom <= ZOOM_SPEED {
self.cam_zoom = ZOOM_SPEED;
}
// Make screen_to_map of cursor_{x,y} still point to the same thing after zooming.
self.cam_x = ((self.cam_zoom / old_zoom) * (self.cursor_x + self.cam_x)) - self.cursor_x;
self.cam_y = ((self.cam_zoom / old_zoom) * (self.cursor_y + self.cam_y)) - self.cursor_y;
}
pub fn get_cursor_in_screen_space(&self) -> ScreenPt {
ScreenPt::new(self.cursor_x, self.cursor_y)
}
pub fn get_cursor_in_map_space(&self) -> Pt2D {
self.screen_to_map(self.get_cursor_in_screen_space())
}
pub fn screen_to_map(&self, pt: ScreenPt) -> Pt2D {
Pt2D::new(
(pt.x + self.cam_x) / self.cam_zoom,
(pt.y + self.cam_y) / self.cam_zoom,
)
}
pub fn center_to_screen_pt(&self) -> ScreenPt {
ScreenPt::new(
f64::from(self.window_size.width) / 2.0,
f64::from(self.window_size.height) / 2.0,
)
}
pub fn center_to_map_pt(&self) -> Pt2D {
self.screen_to_map(self.center_to_screen_pt())
}
pub fn center_on_map_pt(&mut self, pt: Pt2D) {
self.cam_x = (pt.x() * self.cam_zoom) - (f64::from(self.window_size.width) / 2.0);
self.cam_y = (pt.y() * self.cam_zoom) - (f64::from(self.window_size.height) / 2.0);
}
fn map_to_screen(&self, pt: Pt2D) -> ScreenPt {
ScreenPt::new(
(pt.x() * self.cam_zoom) - self.cam_x,
(pt.y() * self.cam_zoom) - self.cam_y,
)
}
pub fn get_screen_bounds(&self) -> Bounds {
let mut b = Bounds::new();
b.update(self.screen_to_map(ScreenPt::new(0.0, 0.0)));
b.update(self.screen_to_map(ScreenPt::new(
f64::from(self.window_size.width),
f64::from(self.window_size.height),
)));
b
}
}
2018-09-28 17:52:36 +03:00
pub enum HorizontalAlignment {
Left,
Center,
Right,
}
pub enum VerticalAlignment {
Top,
Center,
Bottom,
}
pub const BOTTOM_LEFT: (HorizontalAlignment, VerticalAlignment) =
(HorizontalAlignment::Left, VerticalAlignment::Bottom);
pub const TOP_RIGHT: (HorizontalAlignment, VerticalAlignment) =
(HorizontalAlignment::Right, VerticalAlignment::Top);
pub const CENTERED: (HorizontalAlignment, VerticalAlignment) =
(HorizontalAlignment::Center, VerticalAlignment::Center);