106 lines
2.5 KiB
Rust
106 lines
2.5 KiB
Rust
ui_element!(Text {
|
|
val: String,
|
|
width: f64,
|
|
height: f64,
|
|
scale_x: f64,
|
|
scale_y: f64,
|
|
rotation: f64,
|
|
r: u8,
|
|
g: u8,
|
|
b: u8,
|
|
a: u8
|
|
});
|
|
|
|
impl Text {
|
|
base_impl!();
|
|
|
|
pub fn new(renderer: &render::Renderer, val: &str, x: f64, y: f64, r: u8, g: u8, b: u8) -> Text {
|
|
ui_create!(Text {
|
|
val: val.to_owned(),
|
|
x: x,
|
|
y: y,
|
|
width: renderer.ui.size_of_string(val),
|
|
height: 18.0,
|
|
scale_x: 1.0,
|
|
scale_y: 1.0,
|
|
rotation: 0.0,
|
|
r: r,
|
|
g: g,
|
|
b: b,
|
|
a: 255
|
|
})
|
|
}
|
|
|
|
fn update(&mut self, renderer: &mut render::Renderer) {
|
|
self.width = renderer.ui.size_of_string(&self.val);
|
|
}
|
|
|
|
fn draw(&mut self, renderer: &mut render::Renderer, r: &Region, width: f64, height: f64, _: f64) -> &Vec<u8> {
|
|
if self.dirty {
|
|
self.dirty = false;
|
|
let sx = r.w / self.width;
|
|
let sy = r.h / self.height;
|
|
let mut text = if self.rotation == 0.0 {
|
|
renderer.ui.new_text_scaled(&self.val, r.x, r.y, sx*self.scale_x, sy*self.scale_y, self.r, self.g, self.b)
|
|
} else {
|
|
let c = self.rotation.cos();
|
|
let s = self.rotation.sin();
|
|
let tmpx = r.w / 2.0;
|
|
let tmpy = r.h / 2.0;
|
|
let w = (tmpx*c - tmpy*s).abs();
|
|
let h = (tmpy*c + tmpx*s).abs();
|
|
renderer.ui.new_text_rotated(&self.val, r.x+w-(r.w / 2.0), r.y+h-(r.h / 2.0), sx*self.scale_x, sy*self.scale_y, self.rotation, self.r, self.g, self.b)
|
|
};
|
|
for e in &mut text.elements {
|
|
e.a = self.a;
|
|
e.layer = self.layer;
|
|
}
|
|
self.data = text.bytes(width, height);
|
|
}
|
|
&self.data
|
|
}
|
|
|
|
pub fn get_size(&self) -> (f64, f64) {
|
|
((self.width + 2.0) * self.scale_x, self.height * self.scale_y)
|
|
}
|
|
|
|
pub fn get_text(&self) -> &str {
|
|
&self.val
|
|
}
|
|
|
|
pub fn set_text(&mut self, renderer: &render::Renderer, val: &str) {
|
|
self.dirty = true;
|
|
self.val = val.to_owned();
|
|
self.width = renderer.ui.size_of_string(val);
|
|
}
|
|
|
|
lazy_field!(width, f64, get_width, set_width);
|
|
lazy_field!(height, f64, get_height, set_height);
|
|
lazy_field!(scale_x, f64, get_scale_x, set_scale_x);
|
|
lazy_field!(scale_y, f64, get_scale_y, set_scale_y);
|
|
lazy_field!(rotation, f64, get_rotation, set_rotation);
|
|
lazy_field!(r, u8, get_r, set_r);
|
|
lazy_field!(g, u8, get_g, set_g);
|
|
lazy_field!(b, u8, get_b, set_b);
|
|
|
|
}
|
|
|
|
impl UIElement for Text {
|
|
fn wrap(self) -> Element {
|
|
Element::Text(self)
|
|
}
|
|
|
|
fn unwrap_ref<'a>(e: &'a Element) -> &'a Text {
|
|
match e {
|
|
&Element::Text(ref val) => val,
|
|
_ => panic!("Incorrect type"),
|
|
}
|
|
}
|
|
|
|
fn unwrap_ref_mut<'a>(e: &'a mut Element) -> &'a mut Text {
|
|
match e {
|
|
&mut Element::Text(ref mut val) => val,
|
|
_ => panic!("Incorrect type"),
|
|
}
|
|
}
|
|
} |