SYMBOL INDEX (227 symbols across 7 files)

FILE: examples/graphics.rs
  function main (line 13) | fn main() {
  function elmesque_demo_form (line 60) | pub fn elmesque_demo_form(secs: f64) -> Form {

FILE: src/color.rs
  type Color (line 22) | pub enum Color {
    method complement (line 108) | pub fn complement(self) -> Color {
    method luminance (line 119) | pub fn luminance(&self) -> f32 {
    method plain_contrast (line 128) | pub fn plain_contrast(self) -> Color {
    method to_hsl (line 133) | pub fn to_hsl(self) -> Hsla {
    method to_rgb (line 144) | pub fn to_rgb(self) -> Rgba {
    method to_fsa (line 155) | pub fn to_fsa(self) -> [f32; 4] {
    method to_byte_fsa (line 161) | pub fn to_byte_fsa(self) -> [u8; 4] {
    method to_hex (line 168) | pub fn to_hex(self) -> String {
    method with_luminance (line 175) | pub fn with_luminance(self, l: f32) -> Color {
    method alpha (line 181) | pub fn alpha(self, alpha: f32) -> Color {
    method with_alpha (line 189) | pub fn with_alpha(self, a: f32) -> Color {
    method highlighted (line 197) | pub fn highlighted(self) -> Color {
    method clicked (line 214) | pub fn clicked(&self) -> Color {
    method invert (line 231) | pub fn invert(self) -> Color {
    method red (line 237) | pub fn red(&self) -> f32 {
    method green (line 243) | pub fn green(&self) -> f32 {
    method blue (line 249) | pub fn blue(&self) -> f32 {
    method set_red (line 255) | pub fn set_red(&mut self, r: f32) {
    method set_green (line 261) | pub fn set_green(&mut self, g: f32) {
    method set_blue (line 267) | pub fn set_blue(&mut self, b: f32) {
  type Colour (line 30) | pub type Colour = Color;
  function rgba (line 36) | pub fn rgba(r: f32, g: f32, b: f32, a: f32) -> Color {
  function rgb (line 43) | pub fn rgb(r: f32, g: f32, b: f32) -> Color {
  function rgba_bytes (line 51) | pub fn rgba_bytes(r: u8, g: u8, b: u8, a: f32) -> Color {
  function rgb_bytes (line 58) | pub fn rgb_bytes(r: u8, g: u8, b: u8) -> Color {
  function hsla (line 66) | pub fn hsla(hue: f32, saturation: f32, lightness: f32, alpha: f32) -> Co...
  function hsl (line 83) | pub fn hsl(hue: f32, saturation: f32, lightness: f32) -> Color {
  function grayscale (line 89) | pub fn grayscale(p: f32) -> Color {
  function greyscale (line 93) | pub fn greyscale(p: f32) -> Color {
  function random (line 99) | pub fn random() -> Color {
  type Hsla (line 277) | pub struct Hsla(pub f32, pub f32, pub f32, pub f32);
  type Rgba (line 282) | pub struct Rgba(pub f32, pub f32, pub f32, pub f32);
  function f32_to_byte (line 287) | pub fn f32_to_byte(c: f32) -> u8 { (c * 255.0) as u8 }
  function rgb_to_hsl (line 291) | pub fn rgb_to_hsl(r: f32, g: f32, b: f32) -> (f32, f32, f32) {
  function hsl_to_rgb (line 313) | pub fn hsl_to_rgb(hue: f32, saturation: f32, lightness: f32) -> (f32, f3...
  type Gradient (line 334) | pub enum Gradient {
  function linear (line 346) | pub fn linear(start: (f64, f64), end: (f64, f64), colors: Vec<(f64, Colo...
  function radial (line 352) | pub fn radial(start: (f64, f64), start_r: f64,
  function light_red (line 367) | pub fn light_red()      -> Color { rgb_bytes(239 , 41  , 41 ) }
  function red (line 369) | pub fn red()            -> Color { rgb_bytes(204 , 0   , 0  ) }
  function dark_red (line 371) | pub fn dark_red()       -> Color { rgb_bytes(164 , 0   , 0  ) }
  function light_orange (line 374) | pub fn light_orange()   -> Color { rgb_bytes(252 , 175 , 62 ) }
  function orange (line 376) | pub fn orange()         -> Color { rgb_bytes(245 , 121 , 0  ) }
  function dark_orange (line 378) | pub fn dark_orange()    -> Color { rgb_bytes(206 , 92  , 0  ) }
  function light_yellow (line 381) | pub fn light_yellow()   -> Color { rgb_bytes(255 , 233 , 79 ) }
  function yellow (line 383) | pub fn yellow()         -> Color { rgb_bytes(237 , 212 , 0  ) }
  function dark_yellow (line 385) | pub fn dark_yellow()    -> Color { rgb_bytes(196 , 160 , 0  ) }
  function light_green (line 388) | pub fn light_green()    -> Color { rgb_bytes(138 , 226 , 52 ) }
  function green (line 390) | pub fn green()          -> Color { rgb_bytes(115 , 210 , 22 ) }
  function dark_green (line 392) | pub fn dark_green()     -> Color { rgb_bytes(78  , 154 , 6  ) }
  function light_blue (line 395) | pub fn light_blue()     -> Color { rgb_bytes(114 , 159 , 207) }
  function blue (line 397) | pub fn blue()           -> Color { rgb_bytes(52  , 101 , 164) }
  function dark_blue (line 399) | pub fn dark_blue()      -> Color { rgb_bytes(32  , 74  , 135) }
  function light_purple (line 402) | pub fn light_purple()   -> Color { rgb_bytes(173 , 127 , 168) }
  function purple (line 404) | pub fn purple()         -> Color { rgb_bytes(117 , 80  , 123) }
  function dark_purple (line 406) | pub fn dark_purple()    -> Color { rgb_bytes(92  , 53  , 102) }
  function light_brown (line 409) | pub fn light_brown()    -> Color { rgb_bytes(233 , 185 , 110) }
  function brown (line 411) | pub fn brown()          -> Color { rgb_bytes(193 , 125 , 17 ) }
  function dark_brown (line 413) | pub fn dark_brown()     -> Color { rgb_bytes(143 , 89  , 2  ) }
  function black (line 416) | pub fn black()          -> Color { rgb_bytes(0   , 0   , 0  ) }
  function white (line 418) | pub fn white()          -> Color { rgb_bytes(255 , 255 , 255) }
  function light_gray (line 421) | pub fn light_gray()     -> Color { rgb_bytes(238 , 238 , 236) }
  function gray (line 423) | pub fn gray()           -> Color { rgb_bytes(211 , 215 , 207) }
  function dark_gray (line 425) | pub fn dark_gray()      -> Color { rgb_bytes(186 , 189 , 182) }
  function light_grey (line 428) | pub fn light_grey()     -> Color { rgb_bytes(238 , 238 , 236) }
  function grey (line 430) | pub fn grey()           -> Color { rgb_bytes(211 , 215 , 207) }
  function dark_grey (line 432) | pub fn dark_grey()      -> Color { rgb_bytes(186 , 189 , 182) }
  function light_charcoal (line 435) | pub fn light_charcoal() -> Color { rgb_bytes(136 , 138 , 133) }
  function charcoal (line 437) | pub fn charcoal()       -> Color { rgb_bytes(85  , 87  , 83 ) }
  function dark_charcoal (line 439) | pub fn dark_charcoal()  -> Color { rgb_bytes(46  , 52  , 54 ) }
  type Colorable (line 444) | pub trait Colorable: Sized {
    method color (line 447) | fn color(self, color: Color) -> Self;
    method rgba (line 450) | fn rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
    method rgb (line 455) | fn rgb(self, r: f32, g: f32, b: f32) -> Self {
    method hsla (line 460) | fn hsla(self, h: f32, s: f32, l: f32, a: f32) -> Self {
    method hsl (line 465) | fn hsl(self, h: f32, s: f32, l: f32) -> Self {

FILE: src/element.rs
  type Properties (line 66) | pub struct Properties {
  type Element (line 80) | pub struct Element {
    method width (line 90) | pub fn width(self, new_width: i32) -> Element {
    method height (line 106) | pub fn height(self, new_height: i32) -> Element {
    method size (line 122) | pub fn size(self, new_w: i32, new_h: i32) -> Element {
    method opacity (line 128) | pub fn opacity(mut self, opacity: f32) -> Element {
    method color (line 135) | pub fn color(mut self, color: Color) -> Element {
    method crop (line 142) | pub fn crop(self, x: f64, y: f64, w: f64, h: f64) -> Element {
    method container (line 151) | pub fn container(self, w: i32, h: i32, pos: Position) -> Element {
    method clear (line 158) | pub fn clear(self, color: Color) -> Element {
    method above (line 165) | pub fn above(self, other: Element) -> Element {
    method below (line 173) | pub fn below(self, other: Element) -> Element {
    method beside (line 180) | pub fn beside(self, other: Element) -> Element {
    method get_width (line 187) | pub fn get_width(&self) -> i32 { self.props.width }
    method get_height (line 190) | pub fn get_height(&self) -> i32 { self.props.height }
    method get_size (line 193) | pub fn get_size(&self) -> (i32, i32) { (self.props.width, self.props.h...
    method draw (line 197) | pub fn draw<'a, C, G>(&self, renderer: &mut Renderer<'a, C, G>)
    method is_over (line 213) | pub fn is_over(&self, x: i32, y: i32) -> bool {
  function size_of (line 220) | pub fn size_of(e: &Element) -> (i32, i32) {
  function new_element (line 228) | pub fn new_element(w: i32, h: i32, element: Prim) -> Element {
  function spacer (line 243) | pub fn spacer(w: i32, h: i32) -> Element {
  function empty (line 249) | pub fn empty() -> Element {
  type Prim (line 256) | pub enum Prim {
  type ImageStyle (line 268) | pub enum ImageStyle {
  function image (line 277) | pub fn image(w: i32, h: i32, path: PathBuf) -> Element {
  function fitted_image (line 283) | pub fn fitted_image(w: i32, h: i32, path: PathBuf) -> Element {
  function cropped_image (line 289) | pub fn cropped_image(x: i32, y: i32, w: i32, h: i32, path: PathBuf) -> E...
  function tiled_image (line 294) | pub fn tiled_image(w: i32, h: i32, path: PathBuf) -> Element {
  type Three (line 300) | pub enum Three { P, Z, N }
  type Pos (line 302) | pub enum Pos { Absolute(i32), Relative(f32) }
  type Position (line 306) | pub struct Position {
  type Direction (line 315) | pub enum Direction { Up, Down, Left, Right, In, Out }
  function flow (line 320) | pub fn flow(dir: Direction, elements: Vec<Element>) -> Element {
  function layers (line 335) | pub fn layers(elements: Vec<Element>) -> Element {
  function absolute (line 343) | pub fn absolute(i: i32) -> Pos { Pos::Absolute(i) }
  function relative (line 344) | pub fn relative(f: f32) -> Pos { Pos::Relative(f) }
  function p (line 347) | fn p(h: Three, v: Three, x: Pos, y: Pos) -> Position {
  function middle (line 351) | pub fn middle()       -> Position { p(Z, Z, relative(0.5), relative(0.5)) }
  function top_left (line 352) | pub fn top_left()     -> Position { p(N, P, absolute(0), absolute(0)) }
  function top_right (line 353) | pub fn top_right()    -> Position { p(P, P, absolute(0), absolute(0)) }
  function bottom_left (line 354) | pub fn bottom_left()  -> Position { p(N, N, absolute(0), absolute(0)) }
  function bottom_right (line 355) | pub fn bottom_right() -> Position { p(P, N, absolute(0), absolute(0)) }
  function mid_left (line 356) | pub fn mid_left()     -> Position { p(N, Z, absolute(0), relative(0.5)) }
  function mid_right (line 357) | pub fn mid_right()    -> Position { p(P, Z, absolute(0), relative(0.5)) }
  function mid_top (line 358) | pub fn mid_top()      -> Position { p(Z, P, relative(0.5), absolute(0)) }
  function mid_bottom (line 359) | pub fn mid_bottom()   -> Position { p(Z, N, relative(0.5), absolute(0)) }
  function middle_at (line 361) | pub fn middle_at(x: Pos, y: Pos)       -> Position { p(Z, Z, x, y) }
  function top_left_at (line 362) | pub fn top_left_at(x: Pos, y: Pos)     -> Position { p(N, P, x, y) }
  function top_right_at (line 363) | pub fn top_right_at(x: Pos, y: Pos)    -> Position { p(P, P, x, y) }
  function bottom_left_at (line 364) | pub fn bottom_left_at(x: Pos, y: Pos)  -> Position { p(N, N, x, y) }
  function bottom_right_at (line 365) | pub fn bottom_right_at(x: Pos, y: Pos) -> Position { p(P, N, x, y) }
  function mid_left_at (line 366) | pub fn mid_left_at(x: Pos, y: Pos)     -> Position { p(N, Z, x, y) }
  function mid_right_at (line 367) | pub fn mid_right_at(x: Pos, y: Pos)    -> Position { p(P, Z, x, y) }
  function mid_top_at (line 368) | pub fn mid_top_at(x: Pos, y: Pos)      -> Position { p(Z, P, x, y) }
  function mid_bottom_at (line 369) | pub fn mid_bottom_at(x: Pos, y: Pos)   -> Position { p(Z, N, x, y) }
  function up (line 371) | pub fn up() -> Direction { Direction::Up }
  function down (line 372) | pub fn down() -> Direction { Direction::Down }
  function left (line 373) | pub fn left() -> Direction { Direction::Left }
  function right (line 374) | pub fn right() -> Direction { Direction::Right }
  function inward (line 375) | pub fn inward() -> Direction { Direction::In }
  function outward (line 376) | pub fn outward() -> Direction { Direction::Out }
  type Renderer (line 392) | pub struct Renderer<'a, C: 'a, G: 'a> {
  function new (line 401) | pub fn new(context: Context, backend: &'a mut G) -> Renderer<'a, C, G> {
  function character_cache (line 410) | pub fn character_cache(self, character_cache: &'a mut C) -> Renderer<'a,...
  function draw_element (line 419) | pub fn draw_element<'a, C: CharacterCache, G: Graphics<Texture=C::Textur...

FILE: src/form.rs
  type Form (line 48) | pub struct Form {
    method new (line 155) | fn new(basic_form: BasicForm) -> Form {
    method shift (line 170) | pub fn shift(self, x: f64, y: f64) -> Form {
    method shift_x (line 178) | pub fn shift_x(self, x: f64) -> Form {
    method shift_y (line 186) | pub fn shift_y(self, y: f64) -> Form {
    method scale (line 194) | pub fn scale(self, scale: f64) -> Form {
    method rotate (line 202) | pub fn rotate(self, theta: f64) -> Form {
    method alpha (line 209) | pub fn alpha(self, alpha: f32) -> Form {
  type FillStyle (line 59) | pub enum FillStyle {
  type LineCap (line 67) | pub enum LineCap {
  type LineJoin (line 75) | pub enum LineJoin {
  type LineStyle (line 83) | pub struct LineStyle {
    method default (line 96) | pub fn default() -> LineStyle {
    method width (line 109) | pub fn width(self, w: f64) -> LineStyle {
  function solid (line 117) | pub fn solid(color: Color) -> LineStyle {
  function dashed (line 122) | pub fn dashed(color: Color) -> LineStyle {
  function dotted (line 127) | pub fn dotted(color: Color) -> LineStyle {
  type BasicForm (line 134) | pub enum BasicForm {
  type ShapeStyle (line 147) | pub enum ShapeStyle {
  function to_form (line 218) | pub fn to_form(element: Element) -> Form {
  function group (line 225) | pub fn group(forms: Vec<Form>) -> Form {
  function group_transform (line 231) | pub fn group_transform(matrix: Transform2D, forms: Vec<Form>) -> Form {
  function traced (line 237) | pub fn traced(style: LineStyle, path: PointPath) -> Form {
  function line (line 243) | pub fn line(style: LineStyle, x1: f64, y1: f64, x2: f64, y2: f64) -> Form {
  function sprite (line 249) | pub fn sprite(w: i32, h: i32, pos: (i32, i32), path: PathBuf) -> Form {
  function collage (line 256) | pub fn collage(w: i32, h: i32, forms: Vec<Form>) -> Element {
  type PointPath (line 263) | pub struct PointPath(pub Vec<(f64, f64)>);
  function point_path (line 267) | pub fn point_path(points: Vec<(f64, f64)>) -> PointPath {
  function segment (line 273) | pub fn segment(a: (f64, f64), b: (f64, f64)) -> PointPath {
  type Shape (line 280) | pub struct Shape(pub Vec<(f64, f64)>);
    method fill (line 286) | fn fill(self, style: FillStyle) -> Form {
    method filled (line 293) | pub fn filled(self, color: Color) -> Form {
    method textured (line 301) | pub fn textured(self, path: PathBuf) -> Form {
    method gradient (line 308) | pub fn gradient(self, grad: Gradient) -> Form {
    method outlined (line 315) | pub fn outlined(self, style: LineStyle) -> Form {
  function polygon (line 325) | pub fn polygon(points: Vec<(f64, f64)>) -> Shape {
  function rect (line 331) | pub fn rect(w: f64, h: f64) -> Shape {
  function square (line 339) | pub fn square(n: f64) -> Shape {
  function oval (line 345) | pub fn oval(w: f64, h: f64) -> Shape {
  function circle (line 357) | pub fn circle(r: f64) -> Shape {
  function ngon (line 365) | pub fn ngon(n: usize, r: f64) -> Shape {
  function text (line 375) | pub fn text(t: Text) -> Form {
  function draw_form (line 396) | pub fn draw_form<'a, C: CharacterCache, G: Graphics<Texture=C::Texture>>(
  function convert_color (line 531) | fn convert_color(color: Color, alpha: f32) -> [f32; 4] {

FILE: src/text.rs
  type Text (line 8) | pub struct Text {
    method from_string (line 80) | pub fn from_string(string: String) -> Text {
    method empty (line 88) | pub fn empty() -> Text {
    method append (line 94) | pub fn append(mut self, other: Text) -> Text {
    method concat (line 100) | pub fn concat(texts: Vec<Text>) -> Text {
    method join (line 111) | pub fn join(separator: Text, texts: Vec<Text>) -> Text {
    method style (line 123) | pub fn style(self, style: Style) -> Text {
    method typeface (line 135) | pub fn typeface(mut self, path: PathBuf) -> Text {
    method monospace (line 147) | pub fn monospace(mut self) -> Text {
    method height (line 156) | pub fn height(mut self, h: f64) -> Text {
    method color (line 165) | pub fn color(mut self, color: Color) -> Text {
    method bold (line 174) | pub fn bold(mut self) -> Text {
    method italic (line 183) | pub fn italic(mut self) -> Text {
    method line (line 192) | pub fn line(mut self, line: Line) -> Text {
    method position (line 201) | pub fn position(mut self, position: Position) -> Text {
  type TextUnit (line 15) | pub struct TextUnit {
  type Line (line 22) | pub enum Line {
  type Position (line 30) | pub enum Position {
  type Style (line 52) | pub struct Style {
    method default (line 63) | pub fn default() -> Style {

FILE: src/transform_2d.rs
  type Matrix2d (line 18) | pub type Matrix2d = Matrix2x3<f64>;
  type Transform2D (line 22) | pub struct Transform2D(pub Matrix2d);
    method multiply (line 33) | pub fn multiply(self, other: Transform2D) -> Transform2D {
  function identity (line 47) | pub fn identity() -> Transform2D {
  function matrix (line 58) | pub fn matrix(a: f64, b: f64, c: f64, d: f64, x: f64, y: f64) -> Transfo...
  function rotation (line 69) | pub fn rotation(t: f64) -> Transform2D {
  function translation (line 79) | pub fn translation(x: f64, y: f64) -> Transform2D {
  function scale (line 89) | pub fn scale(s: f64) -> Transform2D {
  function scale_x (line 95) | pub fn scale_x(s: f64) -> Transform2D {
  function scale_y (line 101) | pub fn scale_y(s: f64) -> Transform2D {

FILE: src/utils.rs
  function clampf32 (line 8) | pub fn clampf32(f: f32) -> f32 {
  function degrees (line 13) | pub fn degrees<F: Float + NumCast>(d: F) -> F {
  function turns (line 18) | pub fn turns<F: Float + NumCast>(t: F) -> F {
  function modulo (line 25) | pub fn modulo<I: Int>(a: I, b: I) -> I {
  function fmod (line 34) | pub fn fmod(f: f32, n: i32) -> f32 {
  function min (line 40) | pub fn min(a: f32, b: f32) -> f32 {
  function max (line 45) | pub fn max(a: f32, b: f32) -> f32 {
  function clamp (line 51) | pub fn clamp<T: PartialOrd>(val: T, min: T, max: T) -> T {
  function map_range (line 56) | pub fn map_range<X: NumCast, Y: NumCast>