mirrors/stevenarella
mirrors
/
stevenarella
mirror of https://github.com/iceiix/stevenarella.git
1
0
Fork 0
Code Issues 1 Projects Releases Wiki Activity
stevenarella/src/ui/mod.rs

862 lines
19 KiB
Rust
Raw Blame History

// 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.
pub mod logo;
use std::collections::HashMap;
use std::marker::PhantomData;
use std::rc::Rc;
use rand;
use render;
use format;
use screen;
const SCALED_WIDTH: f64 = 854.0;
const SCALED_HEIGHT: f64 = 480.0;
pub enum Element {
Image(Image),
Batch(Batch),
Text(Text),
Formatted(Formatted),
None,
}
pub type ClickFunc = Rc<Fn(&mut screen::ScreenSystem, &mut render::Renderer, &mut Container)>;
pub type HoverFunc = Rc<Fn(bool, &mut screen::ScreenSystem, &mut render::Renderer, &mut Container)>;
macro_rules! element_impl {
($($name:ident),+) => (
impl Element {
fn get_click_funcs(&self) -> Vec<ClickFunc> {
match self {
$(
&Element::$name(ref val) => val.click_funcs.clone(),
)+
_ => unimplemented!(),
}
}
fn get_hover_funcs(&self) -> Vec<HoverFunc> {
match self {
$(
&Element::$name(ref val) => val.hover_funcs.clone(),
)+
_ => unimplemented!(),
}
}
fn should_call_hover(&mut self, new: bool) -> bool{
match self {
$(
&mut Element::$name(ref mut val) => {
let ret = val.hovered != new;
val.hovered = new;
ret
},
)+
_ => unimplemented!(),
}
}
fn should_draw(&self) -> bool {
match self {
$(
&Element::$name(ref val) => val.should_draw,
)+
_ => unimplemented!(),
}
}
fn get_parent(&self) -> Option<ElementRefInner> {
match self {
$(
&Element::$name(ref val) => val.parent,
)+
_ => unimplemented!(),
}
}
fn get_attachment(&self) -> (VAttach, HAttach) {
match self {
$(
&Element::$name(ref val) => (val.v_attach, val.h_attach),
)+
_ => unimplemented!(),
}
}
fn get_offset(&self) -> (f64, f64) {
match self {
$(
&Element::$name(ref val) => (val.x, val.y),
)+
_ => unimplemented!(),
}
}
fn get_size(&self) -> (f64, f64) {
match self {
$(
&Element::$name(ref val) => val.get_size(),
)+
_ => unimplemented!(),
}
}
fn is_dirty(&self) -> bool {
match self {
$(
&Element::$name(ref val) => val.dirty,
)+
_ => unimplemented!(),
}
}
fn set_dirty(&mut self, dirty: bool) {
match self {
$(
&mut Element::$name(ref mut val) => val.dirty = dirty,
)+
_ => unimplemented!(),
}
}
fn update(&mut self, renderer: &mut render::Renderer) {
match self {
$(
&mut Element::$name(ref mut val) => val.update(renderer),
)+
_ => unimplemented!(),
}
}
fn draw(&mut self, renderer: &mut render::Renderer, r: &Region, width: f64, height: f64, delta: f64) -> &Vec<u8>{
match self {
$(
&mut Element::$name(ref mut val) => val.draw(renderer, r, width, height, delta),
)+
_ => unimplemented!(),
}
}
}
)
}
element_impl!(
Image,
Batch,
Text,
Formatted
);
pub enum Mode {
Scaled,
Unscaled(f64)
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum VAttach {
Top,
Middle,
Bottom,
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum HAttach {
Left,
Center,
Right,
}
#[derive(Clone)]
struct Region {
x: f64,
y: f64,
w: f64,
h: f64,
}
impl Region {
fn intersects(&self, o: &Region) -> bool {
!(self.x+self.w < o.x ||
self.x > o.x+o.w ||
self.y+self.h < o.y ||
self.y > o.y+o.h)
}
}
/// Reference to an element currently attached to a
/// container.
#[derive(Copy)]
pub struct ElementRef<T> {
inner: ElementRefInner,
ty: PhantomData<T>,
}
impl <T> Clone for ElementRef<T> {
fn clone(&self) -> Self {
ElementRef {
inner: self.inner,
ty: PhantomData,
}
}
}
#[derive(Hash, PartialEq, Eq, Clone, Copy)]
struct ElementRefInner {
index: usize,
}
impl <T> Default for ElementRef<T> {
fn default() -> Self {
ElementRef {
inner: ElementRefInner{ index: 0 },
ty: PhantomData,
}
}
}
/// Allows for easy cleanup
pub struct Collection {
elements: Vec<ElementRefInner>,
}
impl Collection {
pub fn new() -> Collection {
Collection {
elements: Vec::new(),
}
}
pub fn add<T: UIElement>(&mut self, element: ElementRef<T>) -> ElementRef<T> {
self.elements.push(element.inner);
element
}
pub fn remove_all(&mut self, container: &mut Container) {
for e in &self.elements {
container.remove_raw(e);
}
}
}
const SCREEN: Region = Region{x: 0.0, y: 0.0, w: SCALED_WIDTH, h: SCALED_HEIGHT};
pub struct Container {
pub mode: Mode,
elements: HashMap<ElementRefInner, Element>,
// We need the order
elements_list: Vec<ElementRefInner>,
version: usize,
last_sw: f64,
last_sh: f64,
last_width: f64,
last_height: f64,
}
impl Container {
pub fn new() -> Container {
Container {
mode: Mode::Scaled,
elements: HashMap::new(),
elements_list: Vec::new(),
version: 0xFFFF,
last_sw: 0.0,
last_sh: 0.0,
last_width: 0.0,
last_height: 0.0,
}
}
pub fn add<T: UIElement>(&mut self, e: T) -> ElementRef<T> {
let mut r = ElementRefInner{index: rand::random()};
while self.elements.contains_key(&r) {
r = ElementRefInner{index: rand::random()};
}
self.elements.insert(r, e.wrap());
self.elements_list.push(r);
ElementRef{inner: r, ty: PhantomData}
}
pub fn get<T: UIElement>(&self, r: &ElementRef<T>) -> &T {
T::unwrap_ref(self.elements.get(&r.inner).unwrap())
}
pub fn get_mut<T: UIElement>(&mut self, r: &ElementRef<T>) -> &mut T {
T::unwrap_ref_mut(self.elements.get_mut(&r.inner).unwrap())
}
pub fn remove<T: UIElement>(&mut self, r: &ElementRef<T>) {
self.remove_raw(&r.inner);
}
fn remove_raw(&mut self, r: &ElementRefInner) {
self.elements.remove(&r);
self.elements_list.iter()
.position(|&e| e.index == r.index)
.map(|e| self.elements_list.remove(e))
.unwrap();
}
pub fn tick(&mut self, renderer: &mut render::Renderer, delta: f64, width: f64, height: f64) {
let (sw, sh) = match self.mode {
Mode::Scaled => (SCALED_WIDTH / width, SCALED_HEIGHT / height),
Mode::Unscaled(scale) => (scale, scale),
};
if self.last_sw != sw || self.last_sh != sh
|| self.last_width != width || self.last_height != height
|| self.version != renderer.ui.version {
self.last_sw = sw;
self.last_sh = sh;
self.last_width = width;
self.last_height = height;
for (_, e) in &mut self.elements {
e.set_dirty(true);
if self.version != renderer.ui.version {
e.update(renderer);
}
}
self.version = renderer.ui.version;
}
// Borrow rules seems to prevent us from doing this in the first pass
// so we split it.
let regions = self.collect_elements(sw, sh);
for re in &self.elements_list {
let mut e = self.elements.get_mut(re).unwrap();
if !e.should_draw() {
continue;
}
if let Some(&(ref r, ref dirty)) = regions.get(re) {
e.set_dirty(*dirty);
let data = e.draw(renderer, r, width, height, delta);
renderer.ui.add_bytes(data);
}
}
}
fn collect_elements(&self, sw: f64, sh: f64) -> HashMap<ElementRefInner, (Region, bool)> {
let mut map = HashMap::new();
for (re, e) in &self.elements {
if !e.should_draw() {
continue;
}
let r = self.get_draw_region(e, sw, sh);
if r.intersects(&SCREEN) {
// Mark this as dirty if any of its
// parents are dirty too.
let mut dirty = e.is_dirty();
let mut parent = e.get_parent();
while !dirty && parent.is_some() {
let p = self.elements.get(&parent.unwrap()).unwrap();
dirty = p.is_dirty();
parent = p.get_parent();
}
map.insert(*re, (r, dirty));
}
}
map
}
pub fn click_at(&mut self, screen_sys: &mut screen::ScreenSystem, renderer: &mut render::Renderer, x: f64, y: f64, width: f64, height: f64) {
let (sw, sh) = match self.mode {
Mode::Scaled => (SCALED_WIDTH / width, SCALED_HEIGHT / height),
Mode::Unscaled(scale) => (scale, scale),
};
let mx = (x / width) * SCALED_WIDTH;
let my = (y / height) * SCALED_HEIGHT;
let mut click = None;
for re in self.elements_list.iter().rev() {
let e = self.elements.get(re).unwrap();
let funcs = e.get_click_funcs();
if !funcs.is_empty() {
let r = self.get_draw_region(e, sw, sh);
if mx >= r.x && mx <= r.x + r.w && my >= r.y && my <= r.y + r.h {
click = Some(funcs);
break;
}
}
}
if let Some(click) = click {
for c in &click {
c(screen_sys, renderer, self);
}
}
}
pub fn hover_at(&mut self, screen_sys: &mut screen::ScreenSystem, renderer: &mut render::Renderer, x: f64, y: f64, width: f64, height: f64) {
let (sw, sh) = match self.mode {
Mode::Scaled => (SCALED_WIDTH / width, SCALED_HEIGHT / height),
Mode::Unscaled(scale) => (scale, scale),
};
let mx = (x / width) * SCALED_WIDTH;
let my = (y / height) * SCALED_HEIGHT;
let mut hovers = Vec::new();
for re in self.elements_list.iter().rev() {
let e = self.elements.get(re).unwrap();
let funcs = e.get_hover_funcs();
if !funcs.is_empty() {
let r = self.get_draw_region(e, sw, sh);
hovers.push((*re, funcs, mx >= r.x && mx <= r.x + r.w && my >= r.y && my <= r.y + r.h));
}
}
for hover in &hovers {
let call = {
let e = self.elements.get_mut(&hover.0).unwrap();
e.should_call_hover(hover.2)
};
if call {
for f in &hover.1 {
f(hover.2, screen_sys, renderer, self);
}
}
}
}
fn get_draw_region(&self, e: &Element, sw: f64, sh: f64) -> Region {
let super_region = match e.get_parent() {
Some(ref p) => self.get_draw_region(self.elements.get(p).unwrap(), sw, sh),
None => SCREEN,
};
Container::get_draw_region_raw(e, sw, sh, &super_region)
}
fn get_draw_region_raw(e: &Element, sw: f64, sh: f64, super_region: &Region) -> Region {
let mut r = Region{x:0.0,y:0.0,w:0.0,h:0.0};
let (w, h) = e.get_size();
let (ox, oy) = e.get_offset();
r.w = w * sw;
r.h = h * sh;
let (v_attach, h_attach) = e.get_attachment();
match h_attach {
HAttach::Left => r.x = ox * sw,
HAttach::Center => r.x = (super_region.w / 2.0) - (r.w / 2.0) + ox * sw,
HAttach::Right => r.x = super_region.w - ox * sw - r.w,
}
match v_attach {
VAttach::Top => r.y = oy * sh,
VAttach::Middle => r.y = (super_region.h / 2.0) - (r.h / 2.0) + oy * sh,
VAttach::Bottom => r.y = super_region.h - oy * sh - r.h,
}
r.x += super_region.x;
r.y += super_region.y;
r
}
}
pub trait UIElement {
fn wrap(self) -> Element;
fn unwrap_ref<'a>(&'a Element) -> &'a Self;
fn unwrap_ref_mut<'a>(&'a mut Element) -> &'a mut Self;
}
macro_rules! lazy_field {
($name:ident, $t:ty, $get:ident, $set:ident) => (
pub fn $get(&self) -> $t {
self.$name
}
pub fn $set(&mut self, val: $t) {
if self.$name != val {
self.$name = val;
self.dirty = true;
}
}
)
}
macro_rules! ui_element {
(
$name:ident {
$(
$field:ident : $field_ty:ty
),+
}
) => (
pub struct $name {
dirty: bool,
data: Vec<u8>,
parent: Option<ElementRefInner>,
should_draw: bool,
layer: isize,
x: f64,
y: f64,
v_attach: VAttach,
h_attach: HAttach,
click_funcs: Vec<ClickFunc>,
hover_funcs: Vec<HoverFunc>,
hovered: bool,
$(
$field: $field_ty
),+
}
)
}
macro_rules! base_impl {
() => (
pub fn set_parent<T: UIElement>(&mut self, other: &ElementRef<T>) {
self.parent = Some(other.inner);
self.dirty = true;
}
pub fn add_click_func(&mut self, f: ClickFunc) {
self.click_funcs.push(f);
}
pub fn add_hover_func(&mut self, f: HoverFunc) {
self.hover_funcs.push(f);
}
lazy_field!(layer, isize, get_layer, set_layer);
lazy_field!(x, f64, get_x, set_x);
lazy_field!(y, f64, get_y, set_y);
lazy_field!(v_attach, VAttach, get_v_attach, set_v_attach);
lazy_field!(h_attach, HAttach, get_h_attach, set_h_attach);
)
}
macro_rules! ui_create {
($name:ident {
$($field:ident: $e:expr),+
}) => (
$name {
dirty: true,
data: Vec::new(),
parent: None,
should_draw: true,
layer: 0,
v_attach: VAttach::Top,
h_attach: HAttach::Left,
click_funcs: Vec::new(),
hover_funcs: Vec::new(),
hovered: false,
$($field: $e),+
}
)
}
ui_element!(Image {
texture: render::Texture,
width: f64,
height: f64,
t_x: f64,
t_y: f64,
t_width: f64,
t_height: f64,
r: u8,
g: u8,
b: u8,
a: u8
});
impl Image {
base_impl!();
pub fn new(texture: render::Texture, x: f64, y: f64, w: f64, h: f64, t_x: f64, t_y: f64, t_width: f64, t_height: f64, r: u8, g: u8, b: u8) -> Image {
ui_create!(Image {
texture: texture,
x: x,
y: y,
width: w,
height: h,
t_x: t_x,
t_y: t_y,
t_width: t_width,
t_height: t_height,
r: r,
g: g,
b: b,
a: 255
})
}
fn update(&mut self, _: &mut render::Renderer) {}
fn draw(&mut self, renderer: &mut render::Renderer, r: &Region, width: f64, height: f64, _: f64) -> &Vec<u8> {
if self.dirty {
self.dirty = false;
self.texture = renderer.check_texture(self.texture.clone());
let mut e = render::ui::UIElement::new(&self.texture, r.x, r.y, r.w, r.h, self.t_x, self.t_y, self.t_width, self.t_height);
e.r = self.r;
e.g = self.g;
e.b = self.b;
e.a = self.a;
e.layer = self.layer;
self.data = e.bytes(width, height);
}
&self.data
}
pub fn get_size(&self) -> (f64, f64) {
(self.width, self.height)
}
pub fn get_texture(&self) -> render::Texture {
self.texture.clone()
}
pub fn set_texture(&mut self, val: render::Texture) {
self.texture = val;
self.dirty = true;
}
lazy_field!(width, f64, get_width, set_width);
lazy_field!(height, f64, get_height, set_height);
lazy_field!(t_x, f64, get_t_x, set_t_x);
lazy_field!(t_y, f64, get_t_y, set_t_y);
lazy_field!(t_width, f64, get_t_width, set_t_width);
lazy_field!(t_height, f64, get_t_height, set_t_height);
lazy_field!(r, u8, get_r, set_r);
lazy_field!(g, u8, get_g, set_g);
lazy_field!(b, u8, get_b, set_b);
lazy_field!(a, u8, get_a, set_a);
}
impl UIElement for Image {
fn wrap(self) -> Element {
Element::Image(self)
}
fn unwrap_ref<'a>(e: &'a Element) -> &'a Image {
match e {
&Element::Image(ref val) => val,
_ => panic!("Incorrect type"),
}
}
fn unwrap_ref_mut<'a>(e: &'a mut Element) -> &'a mut Image {
match e {
&mut Element::Image(ref mut val) => val,
_ => panic!("Incorrect type"),
}
}
}
#[derive(Clone, Copy)]
pub struct BatchRef<T: UIElement> {
index: usize,
ty: PhantomData<T>,
}
ui_element!(Batch {
width: f64,
height: f64,
elements: Vec<Element>
});
impl Batch {
base_impl!();
pub fn new(x: f64, y: f64, w: f64, h: f64) -> Batch {
ui_create!(Batch {
x: x,
y: y,
width: w,
height: h,
elements: Vec::new()
})
}
fn update(&mut self, _: &mut render::Renderer) {}
fn draw(&mut self, renderer: &mut render::Renderer, r: &Region, width: f64, height: f64, delta: f64) -> &Vec<u8> {
if self.dirty {
self.dirty = false;
self.data.clear();
let sx = r.w / self.width;
let sy = r.h / self.height;
for e in &mut self.elements {
let reg = Container::get_draw_region_raw(e, sx, sy, r);
e.set_dirty(true);
self.data.extend(e.draw(renderer, &reg, width, height, delta));
}
}
&self.data
}
pub fn get_size(&self) -> (f64, f64) {
(self.width, self.height)
}
pub fn add<T: UIElement>(&mut self, e: T) -> BatchRef<T> {
self.elements.push(e.wrap());
BatchRef { index: self.elements.len() - 1, ty: PhantomData }
}
pub fn get<T: UIElement>(&self, r: BatchRef<T>) -> &T {
T::unwrap_ref(&self.elements[r.index])
}
pub fn get_mut<T: UIElement>(&mut self, r: BatchRef<T>) -> &mut T {
self.dirty = true;
T::unwrap_ref_mut(&mut self.elements[r.index])
}
pub fn get_mut_at<T: UIElement>(&mut self, index: usize) -> &mut T {
self.dirty = true;
T::unwrap_ref_mut(&mut self.elements[index])
}
pub fn len(&self) -> usize {
self.elements.len()
}
lazy_field!(width, f64, get_width, set_width);
lazy_field!(height, f64, get_height, set_height);
}
impl UIElement for Batch {
fn wrap(self) -> Element {
Element::Batch(self)
}
fn unwrap_ref<'a>(e: &'a Element) -> &'a Batch {
match e {
&Element::Batch(ref val) => val,
_ => panic!("Incorrect type"),
}
}
fn unwrap_ref_mut<'a>(e: &'a mut Element) -> &'a mut Batch {
match e {
&mut Element::Batch(ref mut val) => val,
_ => panic!("Incorrect type"),
}
}
}
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"),
}
}
}
// Include instead of mod so we can access private parts
include!("formatted.rs");
Reference in New Issue View Git Blame Copy Permalink