144 lines
3.7 KiB
Rust
144 lines
3.7 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!(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"),
|
|
}
|
|
}
|
|
}
|