stevenarella/src/ui/formatted.rs

pub struct Formatted {
	dirty: bool,
	data: Vec<u8>,

	parent: Option<ElementRefInner>,
	should_draw: bool,
	layer: isize,
	val: format::Component,
	x: f64,
	y: f64,
	width: f64,
	height: f64,
	v_attach: VAttach,
	h_attach: HAttach,
	scale_x: f64,
	scale_y: f64,

	text: Vec<Element>,
	max_width: f64,
	lines: usize,
}

impl Formatted {
	pub fn new(renderer: &mut render::Renderer, val: format::Component, x: f64, y: f64) -> Formatted {
		let mut f = Formatted {
			dirty: true,
			data: Vec::new(),

			parent: None,
			should_draw: true,
			layer: 0,
			val: val,
			x: x,
			y: y,
			width: 0.0,
			height: 18.0,
			v_attach: VAttach::Top,
			h_attach: HAttach::Left,
			scale_x: 1.0,
			scale_y: 1.0,

			text: Vec::new(),
			max_width: -1.0,
			lines: 0,
		};
		f.set_component(renderer);
		f
	}

	pub fn with_width_limit(renderer: &mut render::Renderer, val: format::Component, x: f64, y: f64, max_width: f64) -> Formatted {
		let mut f = Formatted {
			dirty: true,
			data: Vec::new(),

			parent: None,
			should_draw: true,
			layer: 0,
			val: val,
			x: x,
			y: y,
			width: 0.0,
			height: 18.0,
			v_attach: VAttach::Top,
			h_attach: HAttach::Left,
			scale_x: 1.0,
			scale_y: 1.0,

			text: Vec::new(),
			max_width: max_width,
			lines: 0,
		};
		f.set_component(renderer);
		f
	}

	fn set_component(&mut self, renderer: &mut render::Renderer) {
		self.text.clear();
		let mut state = FormatState {
			lines: 0,
			width: 0.0,
			offset: 0.0,
			text: Vec::new(),
			max_width: self.max_width,
			renderer: &renderer,
		};
		state.build(&self.val, format::Color::White);
		self.height = (state.lines + 1) as f64 * 18.0;
		self.width = state.width;
		self.lines = state.lines;
		self.text = state.text;
		self.dirty = true;
	}

	fn update(&mut self, renderer: &mut render::Renderer) {
		self.set_component(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.text {
				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 + 2.0) * self.scale_x, self.height * self.scale_y)
	}

	pub fn set_parent<T: UIElement>(&mut self, other: &ElementRef<T>) {
		self.parent = Some(other.inner);
		self.dirty = true;
	}

	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!(width, f64, get_width, set_width);
	lazy_field!(height, f64, get_height, set_height);
	lazy_field!(v_attach, VAttach, get_v_attach, set_v_attach);
	lazy_field!(h_attach, HAttach, get_h_attach, set_h_attach);
	lazy_field!(scale_x, f64, get_scale_x, set_scale_x);
	lazy_field!(scale_y, f64, get_scale_y, set_scale_y);

}

impl UIElement for Formatted {
	fn wrap(self) -> Element {
		Element::Formatted(self)
	}

	fn unwrap_ref<'a>(e: &'a Element) -> &'a Formatted {
		match e {
			&Element::Formatted(ref val) => val,
			_ => panic!("Incorrect type"),
		}
	}

	fn unwrap_ref_mut<'a>(e: &'a mut Element) -> &'a mut Formatted {
		match e {
			&mut Element::Formatted(ref mut val) => val,
			_ => panic!("Incorrect type"),
		}
	}
}

struct FormatState<'a> {
	max_width: f64,
	lines: usize,
	offset: f64,
	width: f64,
	text: Vec<Element>,	
	renderer: &'a render::Renderer,
}

type GetColorFn = Fn() -> format::Color;

impl <'a> FormatState<'a> {
	fn build(&mut self, c: &format::Component, color: format::Color) {
		match c {
			&format::Component::Text(ref txt) => {
				let col = FormatState::get_color(&txt.modifier, color);
				self.append_text(&txt.text, col);
				let modi = &txt.modifier;
				if let Some(ref extra) = modi.extra {
					for e in extra {
						self.build(e, col);
					}
				}
			},
		}
	}

	fn append_text(&mut self, txt: &str, color: format::Color) {
		let mut width = 0.0;
		let mut last = 0;
		for (i, c) in txt.chars().enumerate() {
			let size = self.renderer.ui.size_of_char(c) + 2.0;
			if (self.max_width > 0.0 && self.offset + width + size > self.max_width) || c == '\n' {
				let (rr, gg, bb) = color.to_rgb();
				let text = Text::new(self.renderer, &txt[last .. i], self.offset, (self.lines*18 + 1) as f64, rr, gg, bb);
				self.text.push(text.wrap());
				last = i;
				if c == '\n' {
					last += 1;
				}
				self.offset = 0.0;
				self.lines += 1;
				width = 0.0;
			}
			width += size;
			if self.offset + width > self.width {
				self.width = self.offset + width;
			}
		}

		if last != txt.len() {
			let (rr, gg, bb) = color.to_rgb();
			let text = Text::new(self.renderer, &txt[last..], self.offset, (self.lines*18 + 1) as f64, rr, gg, bb);
			self.offset += text.width + 4.0; // TODO Why is this 4 not 2?
			self.text.push(text.wrap());
			if self.offset > self.width {
				self.width = self.offset;
			}
		}
	}

	fn get_color(modi: &format::Modifier, color: format::Color) -> format::Color {
		modi.color.unwrap_or(color)
	}
}