150 lines
4.4 KiB
Rust
150 lines
4.4 KiB
Rust
// Copyright 2015 Matthew Collins
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
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"),
|
|
}
|
|
}
|
|
}
|