canrust 1.3.3

//! Main structs.
//! Contains Canvas, Shapes, Button, Text
//! Each one has an in depth documentation.

use crate::utils::*;
use sfml::graphics::{
    CircleShape, ConvexShape, Font, RectangleShape, RenderStates, RenderTarget, RenderWindow,
    Shape, Sprite, Text as Tx, Texture, Transformable,
};
use sfml::system::Vector2f;
use sfml::window::{mouse::Button as MButton, ContextSettings, Event, Key, Style, VideoMode};
use std::collections::HashMap;

#[derive(Clone)]
enum Object {
    Circle(Circle),
    Rectangle(Rectangle),
    Line(Line),
    Text(Text),
    Button(Button),
    Image(Image),
    Polygon(Polygon),
}

/// Enum used for retrieving objects from Canvas.
/// Returns a wrapped mutable reference to an object on a canvas.
///
/// Usage:
/// ```no_run
/// use canrust::canvas::{Canvas, Color, Retrieve}
/// //example object creation, after creating objects, they return their id.
/// let circle: u32 = canvas.create_circle((80., 10.), 4., Color::BLUE, None, None);
///     
///
/// // Retrieve an object, than match it and change it's color
/// let _: Retrieve = match canvas.retrieve(circle).expect("failed to retrieve object") {
///     Retrieve::Circle(c) => {
///         c.set_fill_color(Color::RED);
///     },
///     _ => ()
/// };
///
/// ```
pub enum Retrieve<'l> {
    Circle(&'l mut Circle),
    Rectangle(&'l mut Rectangle),
    Line(&'l mut Line),
    Text(&'l mut Text),
    Button(&'l mut Button),
    Image(&'l mut Image),
    Polygon(&'l mut Polygon),
}

struct DefContext {
    c: ContextSettings,
}

impl DefContext {
    fn new() -> Self {
        Self {
            c: ContextSettings::default(),
        }
    }
}

/// Main object responsible for managing a window and rendering stuff.
/// Only one canvas per running application sadly!
pub struct Canvas {
    _size: (u32, u32),
    _name: String,
    bg: Color,
    window: RenderWindow,
    objects: HashMap<u32, Object>,
    counter: u32,
    bound: Vec<(&'static str, fn(&mut Canvas))>,
    bound_mouse: Vec<(&'static str, fn(&mut Canvas, (f32, f32)))>,
}

// Associated functions:
impl Canvas {
    /// Creates a new instance of Canvas, initializes a window with name and gives it a background
    /// color.
    /// ```no_run
    /// use canrust::canvas::*;
    /// use canrust::color::*;
    ///
    /// let size = (800, 600);
    /// let name = String::from("Canvas");
    /// let mut canvas = Canvas::new(size, name, Color::WHITE);
    /// ```
    pub fn new(size: (u32, u32), name: String, bg: Color) -> Self {
        let context = DefContext::new().c;
        Self {
            _size: size,
            _name: name.clone(),
            bg,
            window: RenderWindow::new(
                VideoMode::new(size.0, size.1, 16),
                &name,
                Style::default(),
                &context,
            ),
            objects: HashMap::new(),
            counter: 1u32,
            bound: vec![],
            bound_mouse: vec![],
        }
    }
}

// Methods:
impl Canvas {
    /// Draws a new rectangle onto a Canvas.
    ///
    /// - point_a: coordinates on the Canvas representing top left corner.
    /// - point_b: coordinates on the Canvas representing bottom right corner.
    /// - fill: Color of the rectangle
    /// - outline: Color of the outline of the rectangle
    /// - outline_thickness: thickness of the outline of the rectangle
    ///
    /// ```no_run
    /// // Creates a 40*40 pixel red square with blue outline, 5 pixels thick
    /// canvas.create_rectangle(
    ///     (80., 80.),
    ///     (120., 120.),
    ///     Color::RED,
    ///     Some(Color::BLUE),
    ///     Some(5.));
    /// ```
    pub fn create_rectangle(
        &mut self,
        point_a: (f32, f32),
        point_b: (f32, f32),
        fill: Color,
        outline: Option<Color>,
        outline_thickness: Option<f32>,
    ) -> u32 {
        let mut ret = Rectangle::new(
            (point_b.0 - point_a.0, point_b.1 - point_a.1),
            point_a,
            fill,
        );

        ret.set_outline_color(outline.unwrap_or(fill));
        ret.set_outline_thickness(outline_thickness.unwrap_or(0f32));

        &self
            .objects
            .insert(self.counter, Object::Rectangle(ret.clone()));
        self.increment();

        self.counter - 1
    }

    /// Draws a new line onto the Canvas
    ///
    /// - point_a: coordinates of the first point
    /// - point_b: coordinates of the second point
    /// - thickness: thickness of the line
    /// - fill: color of the line
    /// - outline: outline color of the line
    /// - outline_thickness: thickness of the outline of the line
    ///
    /// ```no_run
    /// // Create a 5 pixel wide green horizontal line without outline
    /// canvas.create_line((80., 10.), (80., 110.), 5., Color::GREEN, None, None);
    ///
    /// ```
    pub fn create_line(
        &mut self,
        point_a: (f32, f32),
        point_b: (f32, f32),
        thickness: f32,
        fill: Color,
        outline: Option<Color>,
        outline_thickness: Option<f32>,
    ) -> u32 {
        let mut ln = Line::new(point_a, point_b, thickness, fill);

        ln.set_outline_color(outline.unwrap_or(fill));
        ln.set_outline_thickness(outline_thickness.unwrap_or(0f32));

        &self.objects.insert(self.counter, Object::Line(ln.clone()));
        self.increment();

        self.counter - 1
    }

    /// Draws a circle onto the Canvas.
    ///
    /// - point: coordinates of the middle of the Circle
    /// - r: radius of the circle
    /// - fill: Color of the circle
    /// - outline: Color of the outline of the circle
    /// - outline_thickness: outline thickness in pixels
    ///
    /// ```no_run
    /// // Create a 40 pixel wide black circle
    /// canvas.create_circle((60., 60), 20., Color::BLACK, None, None);
    /// ```
    pub fn create_circle(
        &mut self,
        point: (f32, f32),
        radius: f32,
        fill: Color,
        outline: Option<Color>,
        out_thickness: Option<f32>,
    ) -> u32 {
        let mut ret = Circle::new(point, radius, fill);

        ret.set_outline_color(outline.unwrap_or(fill));
        ret.set_outline_thickness(out_thickness.unwrap_or(0f32));
        ret.set_origin((radius, radius));

        &self
            .objects
            .insert(self.counter, Object::Circle(ret.clone()));
        self.increment();

        self.counter - 1
    }

    /// Create a convex shape from a vector of points
    ///
    /// - points: Vector of coordinates
    /// - fill: Color of the shape
    /// - outline: Color of the outline of the shape
    /// - outline_thickness: thickness of the outline of the shape in pixels
    ///
    /// ```no_run
    /// let points = Vec::from((1., 1.), (20., 1.), (30., 45.), (1., 35.));
    ///
    /// canvas.create_polygon(points, Color::RED, Some(Color::BLUE), Some(2.));
    ///
    /// ```
    pub fn create_polygon(
        &mut self,
        points: Vec<(f32, f32)>,
        fill: Color,
        outline: Option<Color>,
        outline_thickness: Option<f32>,
    ) -> u32 {
        let mut ret = Polygon::new(points);

        ret.set_fill_color(fill);
        ret.set_outline_color(outline.unwrap_or(fill));
        ret.set_outline_thickness(outline_thickness.unwrap_or(0f32));

        &self
            .objects
            .insert(self.counter, Object::Polygon(ret.clone()));
        self.increment();

        self.counter - 1
    }

    /// Create a horizontal text on a Canvas
    ///
    /// - position: coordinates, where the text will be displayed
    /// - content: what the text would say
    /// - size: text size in pixels
    /// - font: tries to match a font, fails if not found
    /// - fill: text color
    ///
    /// ```no_run
    /// // Create a 15 pixel large black text with "Source Code Pro" font
    /// // linux use font-config
    /// #[cfg(target_os="linux")]
    /// canvas.create_text((30. 30.), "This is a text example", 15, "source code pro", Color::BLACK);
    ///
    /// // Create a 15 pixel large black text with "Arial" font
    /// // windows just checks if the font is in C:\\Windows\\Fonts
    /// // that's why the .ttf is required
    /// #[cfg(target_os="windows")]
    /// canvas.create_text((30., 30.), "This is a text example", 15, "Arial.ttf", Color::BLACK);
    /// ```
    pub fn create_text(
        &mut self,
        position: (f32, f32),
        content: &str,
        size: u32,
        font: &str,
        fill: Color,
    ) -> u32 {
        let mut text = Text::new(content, size, fill, position);

        text.set_font(font.to_string())
            .expect("Font failed to load");

        &self.objects.insert(self.counter, Object::Text(text));
        self.increment();

        self.counter - 1
    }

    /// Creates a text from an existing Text object
    ///
    /// ```no_run
    /// let text = Text::new("This is a text", 15., Color::BLACK, (100., 100.));
    ///
    /// canvas.create_from_text(&text)
    /// ```
    pub fn create_from_text(&mut self, text: &Text) -> u32 {
        &self
            .objects
            .insert(self.counter, Object::Text(text.clone()));
        self.increment();

        self.counter - 1
    }

    /// Crates a button from an existing Button object.
    /// Button is bound to a function, which it calls when when we click it.
    /// This function takes a mutable reference to Canvas and a tuple of f32 coordinates.
    /// Buttons contain text and shape.
    ///
    /// WARNING: Button functions are always mapped to \<Button1>\, so if you want other bound
    /// functions, bind them to a different button!
    ///
    /// - Shape: Rectangle or Circle
    /// (Circle is not yet fully implemented yet, it works bu)
    /// - Text: Basic Text struct
    ///
    /// ```no_run
    /// {
    /// let mut canvas = Canvas::new(/*stuff here */);
    ///
    /// // we can either call Button::new or Button::from_text, which takes an exiting
    /// // text object and configures it for the button
    /// // default button shape is rectangle
    /// let mut button = Button::new("name", (80., 60.), (100., 300.));
    ///
    /// // bind the button to a function
    /// // if we give canvas a button that is not bound to anything,
    /// // we get an error
    /// // (button functions always bind to Button1(left mouse button))
    /// button.bind(my_fn);
    ///
    /// // give the button to canvas for rendering
    /// canvas.create_from_button(&button);
    ///
    ///
    /// fn my_fn(can: &mut Canvas, coords: (f32, f32)) {
    ///     // stuff
    /// }
    /// ```
    pub fn create_from_button(&mut self, button: &Button) -> u32 {
        self.objects
            .insert(self.counter, Object::Button(button.clone()));
        self.increment();

        self.counter - 1
    }

    /// Creates an image on the Canvas, returns the Image for processing.
    ///
    /// - path: absolute path to the image
    /// - position: images position on the Canvas
    ///
    /// ```no_run
    /// canvas.create_image("~/myimage.png", (200. 200.));
    /// ```
    pub fn create_image(&mut self, path: &str, position: (f32, f32)) -> Result<u32, Error> {
        let image = Image::from_file(path, position)?;

        self.objects
            .insert(self.counter, Object::Image(image.clone()));
        self.increment();

        Ok(self.counter - 1)
    }

    /// Creates an image from an Image instance
    ///
    /// ```no_run
    /// let image = Image::from_file("~/myimage.png", (200., 200.));
    ///
    /// canvas.create_from_image(&image)
    /// ```
    pub fn create_from_image(&mut self, image: &Image) -> u32 {
        &self
            .objects
            .insert(self.counter, Object::Image(image.clone()));
        self.increment();

        self.counter - 1
    }

    /// Create a Line from an existing Line object
    ///
    /// ```no_run
    /// let line = Line::new((80., 10.), (80., 110), 5., Color::RED)).expect("Failed to build Line!");
    ///
    /// canvas.create_from_line(&line);
    /// ```
    pub fn create_from_line(&mut self, line: &Line) -> u32 {
        &self
            .objects
            .insert(self.counter, Object::Line(line.clone()));
        self.increment();

        self.counter - 1
    }

    /// Create a new rectangle from an existing Rectangle object
    ///
    /// ```no_run
    /// // Create a custom Rectangle:
    /// let mut rect = Rectangle::new( /* stuff here */);
    ///
    /// // do stuff to it
    /// rect.set_rotation(53.j);
    ///
    /// // Draw it to a Canvas
    /// canvas.create_from_rectangle(&rect);
    ///
    /// ```
    pub fn create_from_rectangle(&mut self, rectangle: &Rectangle) -> u32 {
        &self
            .objects
            .insert(self.counter, Object::Rectangle(rectangle.clone()));
        self.increment();

        self.counter - 1
    }

    /// Create a new circle from an existing Circle object
    ///
    /// ```no_run
    /// // Create a custom circle object
    /// let circle = Circle::new( /*stuff here */ );
    ///
    /// // Do some stuff to it:
    /// circle.set_outline_color(Color::RED);
    ///
    /// // Draw it to a Canvas
    /// canvas.create_from_circle(&circle);
    ///
    /// ```
    pub fn create_from_circle(&mut self, circle: &Circle) -> u32 {
        &self
            .objects
            .insert(self.counter, Object::Circle(circle.clone()));
        self.increment();

        self.counter - 1
    }

    /// Create a new convex shape from an existing object
    ///
    /// ```no_run
    /// // Create a custom object
    /// let mut polygon = Polygon::new(/*fields*/);
    ///
    /// // Do stuff to it:
    /// polygon.set_outline_thickness(5.);
    ///
    /// // Draw to to a Canvas
    /// canvas.create_from_polygon(&polygon);
    ///
    /// ```
    pub fn create_from_polygon(&mut self, polygon: &Polygon) -> u32 {
        &self
            .objects
            .insert(self.counter, Object::Polygon(polygon.clone()));
        self.increment();

        self.counter - 1
    }

    /// Retrieve an object from Canvas, given objects id.
    /// This id is set whenever a object is created.
    ///
    /// ```no_run
    /// // Retrieve first object created on the canvas, or fail if there is no object
    /// let c: Retrieve = canvas.retrieve(1);
    /// ```
    pub fn retrieve(&mut self, key: u32) -> Option<Retrieve> {
        for obj in self.objects.iter_mut() {
            if key == *obj.0 {
                match obj.1 {
                    Object::Circle(c) => return Some(Retrieve::Circle(c)),
                    Object::Line(c) => return Some(Retrieve::Line(c)),
                    Object::Rectangle(c) => return Some(Retrieve::Rectangle(c)),
                    Object::Polygon(c) => return Some(Retrieve::Polygon(c)),
                    Object::Text(c) => return Some(Retrieve::Text(c)),
                    Object::Button(c) => return Some(Retrieve::Button(c)),
                    Object::Image(c) => return Some(Retrieve::Image(c)),
                }
            }
        }
        return None;
    }

    /// Removes all objects from canvas, effectively clearing it
    pub fn clear(&mut self) {
        self.objects.clear();
    }

    /// Retrurn ids of all objects on canvas
    pub fn ids(&mut self) -> Vec<u32> {
        let mut vec: Vec<u32> = Vec::new();

        for (key, _) in self.objects.iter() {
            vec.push(*key)
        }
        vec
    }

    /// Binds an action to a function
    ///
    /// Supported actions:
    /// - a-z
    /// - 0-9
    /// - \<Enter\>, \<Esc>\, \<Space>\
    ///
    /// Function which is being bound, has to have exactly one argument and it has to be a mutable
    /// reference to a Canvas object. This will be the Canvas from which the method is being
    /// called!
    ///
    /// ```no_run
    /// // a function that takes a mutable reference to a canvas
    /// fn my_fn(can: &mut Canvas, _: Vec<u32>) {
    ///     can.create_line((80., 10.), (80, 110.), 5., Color::BLUE);
    /// }
    ///
    /// fn main {
    ///     let canvas = Canvas::new(// fields);
    ///
    ///     canvas.bind("<Enter>", my_fn, canvas.ids());
    ///
    ///     canvas.mainloop()
    /// }
    /// ```
    pub fn bind(&mut self, action: &'static str, func: fn(&mut Canvas)) {
        let pair = (action, func);

        self.bound.push(pair);
    }

    /// Binds a function to a mouse button.
    ///
    /// Supported actions:
    /// - \<Button1\>(left mouse button), \<Button2\>(right mouse button), \<Button3\>(middle mouse
    /// button)
    ///
    /// ```no_run
    ///
    /// // a function that takes a mutable reference to a canvas and a tuple of f32s
    /// fn my_fn(can: &mut Canvas, coords: (f32, f32), _: Vec<u32>) {
    ///     let point_b = (coords.0 + 40., coords.1 + 50.);
    ///     can.create_line(coords, point_b, 5., Color::BLACK, None, None);
    /// }
    ///
    /// fn main {
    ///     let canvas = Canvas::new(/*stuff */);
    ///
    ///     canvas.bind_mouse("<Button1>", my_fn, ids);
    ///
    ///     canvas.mainloop()
    /// }
    /// ```
    pub fn bind_mouse(&mut self, action: &'static str, func: fn(&mut Canvas, (f32, f32))) {
        let pair = (action, func);

        self.bound_mouse.push(pair);
    }

    /// Main function responsible for rendering all the objects onto the Canvas.
    /// Handles both events and rendering.
    ///
    /// ```no_run
    /// let canvas = Canvas::new(/* some fields*/);
    /// canvas.create_rectangle((1., 1.), (100., 100.), Color::RED, None, None);
    ///
    /// // Canvas will not render if mainloop is not present!
    /// canvas.mainloop();
    /// ```
    pub fn mainloop(&mut self) {
        let canvas = self;
        while canvas.window.is_open() {
            canvas.window.clear(canvas.bg.c);
            while let Some(event) = &mut canvas.window.poll_event() {
                match event {
                    Event::Closed => canvas.window.close(),
                    Event::KeyPressed {
                        shift: _,
                        ctrl: _,
                        alt: _,
                        system: _,
                        code,
                    } => {
                        let code = canvas.check_keys(*code);
                        if code == -1 || code == -2 {
                            ()
                        } else {
                            canvas.bound[code as usize].1(canvas);
                        }
                    }
                    Event::MouseButtonPressed { button, x, y } => {
                        let mut fn_pointer: Vec<fn(&mut Canvas, (f32, f32))> = Vec::new();
                        for val in canvas.objects.values() {
                            match val {
                                Object::Button(b) => {
                                    let size = b.get_size();
                                    let pos = b.get_position();
                                    let area_x = (pos.0, pos.0 + size.0);
                                    let area_y = (pos.1, pos.1 + size.1);
                                    if *x as f32 >= area_x.0 && *x as f32 <= area_x.1 {
                                        if *y as f32 >= area_y.0 && *y as f32 <= area_y.1 {
                                            fn_pointer.push(b.func.unwrap());
                                        };
                                    };
                                }
                                _ => (),
                            };
                        }

                        let code = canvas.check_mouse(*button);
                        if code == -1 || code == -2 {
                            for f in fn_pointer {
                                f(canvas, (*x as f32, *y as f32));
                            }
                        } else {
                            canvas.bound_mouse[code as usize].1(canvas, (*x as f32, *y as f32));
                        }
                    }
                    _ => (),
                }
            }
            for object in canvas.objects.clone() {
                match object.1 {
                    Object::Circle(circle) => canvas
                        .window
                        .draw_circle_shape(&circle.shape, RenderStates::default()),
                    Object::Rectangle(rect) => canvas
                        .window
                        .draw_rectangle_shape(&rect.shape, RenderStates::default()),
                    Object::Line(line) => canvas
                        .window
                        .draw_rectangle_shape(&line.shape, RenderStates::default()),
                    Object::Polygon(polygon) => canvas
                        .window
                        .draw_convex_shape(&polygon.shape, RenderStates::default()),
                    Object::Text(text) => {
                        let mut font_path = String::new();
                        match text.get_font() {
                            Some(string) => font_path = string,
                            None => {
                                font_path = FontHandler::find_fonts("Arial".to_string())
                                    .expect("Default font Arial not found!")
                                    .get()
                            }
                        }
                        let font =
                            Font::from_file(font_path.as_str()).expect("Failed to load a font");

                        let mut tex =
                            Tx::new(text.get_contents().clone().as_str(), &font, text.get_size());
                        let pos = text.get_position();
                        tex.set_position(Vector2f::new(pos.0, pos.1));
                        tex.set_fill_color(text.get_fill_color().c);

                        canvas.window.draw_text(&tex, RenderStates::default())
                    }
                    Object::Button(button) => {
                        let text_size = button.text.get_size();
                        let shape_size = button.get_size();
                        let position = button.get_position();

                        let fill_color = button.get_fill_color().unwrap_or(Color::BLACK);

                        if button.style == ButtonStyle::Rectangle() {
                            let mut shape = Rectangle::new(shape_size, position, fill_color);

                            shape.set_outline_color(
                                button.get_outline_color().unwrap_or(fill_color),
                            );
                            shape.set_outline_thickness(button.get_outline_thickness());
                            canvas
                                .window
                                .draw_rectangle_shape(&shape.shape, RenderStates::default());
                        }

                        if button.style == ButtonStyle::Circle() {
                            let mut shape = Circle::new(
                                (position.0, position.1 - shape_size.1 / 3.),
                                shape_size.0 / 2.,
                                fill_color,
                            );

                            shape.set_outline_color(
                                button.get_outline_color().unwrap_or(fill_color),
                            );
                            shape.set_outline_thickness(button.get_outline_thickness());
                            canvas
                                .window
                                .draw_circle_shape(&shape.shape, RenderStates::default())
                        }
                        let text = button.text.clone();
                        let mut font_path: String;
                        match text.get_font() {
                            Some(string) => font_path = string,
                            None => {
                                font_path = FontHandler::find_fonts("Arial".to_string())
                                    .expect("Default font Arial not found!")
                                    .get()
                            }
                        }
                        let font =
                            Font::from_file(font_path.as_str()).expect("Failed to load a font");

                        let mut tex =
                            Tx::new(text.get_contents().clone().as_str(), &font, text.get_size());
                        let pos = text.get_position();
                        tex.set_position(Vector2f::new(pos.0, pos.1));
                        tex.set_fill_color(text.get_fill_color().c);

                        canvas.window.draw_text(&tex, RenderStates::default())
                    }
                    Object::Image(image) => {
                        let texture = match Texture::from_image(&image.image) {
                            Some(tex) => tex,
                            None => panic!("Failed to display image"),
                        };

                        let mut sprite = Sprite::with_texture(&texture);
                        let pos = image.get_position();
                        sprite.set_position(Vector2f::new(pos.0, pos.1));

                        canvas.window.draw_sprite(&sprite, RenderStates::default())
                    }
                }
            }
            canvas.window.display();
        }
    }

    // Handling input for bind functions
    fn check_keys(&self, key: Key) -> i32 {
        let pairs = &self.bound;

        let key_ = match key {
            Key::A => "a",
            Key::B => "b",
            Key::C => "c",
            Key::D => "d",
            Key::E => "e",
            Key::F => "f",
            Key::G => "g",
            Key::H => "h",
            Key::J => "j",
            Key::K => "k",
            Key::L => "l",
            Key::M => "m",
            Key::N => "n",
            Key::O => "o",
            Key::P => "p",
            Key::Q => "q",
            Key::R => "r",
            Key::S => "s",
            Key::T => "t",
            Key::U => "u",
            Key::V => "v",
            Key::W => "w",
            Key::X => "x",
            Key::Y => "y",
            Key::Z => "z",
            Key::Num0 => "0",
            Key::Num1 => "1",
            Key::Num2 => "2",
            Key::Num3 => "3",
            Key::Num4 => "4",
            Key::Num5 => "5",
            Key::Num6 => "6",
            Key::Num7 => "7",
            Key::Num8 => "8",
            Key::Num9 => "9",
            Key::Space => "<Space>",
            Key::Return => "<Enter>",
            Key::Escape => "<Esc>",
            _ => return -1,
        };

        let mut counter = 0i32;

        for pair in pairs.iter() {
            if key_ == pair.0 {
                return counter;
            } else {
                counter += 1
            }
        }

        return -2;
    }

    // handling input for bind_mouse functions
    fn check_mouse(&self, button: MButton) -> i32 {
        let pairs = &self.bound_mouse;

        let button_ = match button {
            MButton::Left => "<Button1>",
            MButton::Right => "<Button2>",
            MButton::Middle => "<Button3>",
            _ => return -1,
        };

        let mut counter = 0i32;

        for pair in pairs.iter() {
            if button_ == pair.0 {
                return counter;
            } else {
                counter += 1
            }
        }

        return -2;
    }

    // Increment counter
    fn increment(&mut self) {
        self.counter += 1;
    }
}

impl Canvas {
    /// Methods for manipulating the Canvas:
    /// Resize Canvas window.
    /// - size a tuple of u32s
    pub fn resize(&mut self, size: (u32, u32)) {
        self.window.set_size(size);
    }

    /// Returns the size of the Canvas
    pub fn get_size(&self) -> (u32, u32) {
        let size = self.window.size();
        return (size.x, size.y);
    }

    /// Changes the Canvas' window title
    /// - name: String
    pub fn set_title(&mut self, name: String) {
        self.window.set_title(&name);
        self._name = name;
    }

    /// Return Canvas' window title
    pub fn title(&self) -> String {
        return self._name.clone();
    }
}

// Color
#[derive(Clone, Copy, Debug, PartialEq)]
/// Representation of a RGB or RGBA color.
pub struct Color {
    pub c: sfml::graphics::Color,
}

impl Color {
    /// Creates a RGB color.
    pub fn rgb(r: u8, g: u8, b: u8) -> Self {
        Self {
            c: sfml::graphics::Color::rgb(r, g, b),
        }
    }

    /// Cretes a RGBA color.
    pub fn rgba(r: u8, g: u8, b: u8, a: u8) -> Self {
        Self {
            c: sfml::graphics::Color::rgba(r, g, b, a),
        }
    }

    pub(crate) fn from_sfml_color(c: sfml::graphics::Color) -> Self {
        Self { c }
    }

    pub const BLACK: Self = Self {
        c: sfml::graphics::Color::BLACK,
    };
    pub const WHITE: Self = Self {
        c: sfml::graphics::Color::WHITE,
    };
    pub const RED: Self = Self {
        c: sfml::graphics::Color::RED,
    };
    pub const GREEN: Self = Self {
        c: sfml::graphics::Color::GREEN,
    };
    pub const BLUE: Self = Self {
        c: sfml::graphics::Color::BLUE,
    };
    pub const YELLOW: Self = Self {
        c: sfml::graphics::Color::YELLOW,
    };
    pub const MAGENTA: Self = Self {
        c: sfml::graphics::Color::MAGENTA,
    };
    pub const CYAN: Self = Self {
        c: sfml::graphics::Color::CYAN,
    };
}

// Shapes
/// Representation of a Rectangle object.
#[derive(Clone)]
pub struct Rectangle {
    pub(crate) shape: RectangleShape<'static>,
}

impl Rectangle {
    /// Creates new Rectangle object.
    /// Requires from two tuples of f32s and a Color
    pub fn new(size: (f32, f32), position: (f32, f32), color: Color) -> Self {
        let mut rect = RectangleShape::new();
        let size = Vector2f::new(size.0, size.1);
        let position = Vector2f::new(position.0, position.1);

        rect.set_size(size);
        rect.set_position(position);
        rect.set_fill_color(color.c);

        Self { shape: rect }
    }
    /// Creates a new Rectangle object from an existing one
    pub fn from_rect(rect: &Rectangle) -> Option<Self> {
        Some(Self {
            shape: rect.shape.clone(),
        })
    }
}

impl Rectangle {
    /// Set fill color of the Rectangle
    pub fn set_fill_color(&mut self, color: Color) {
        &self.shape.set_fill_color(color.c);
    }
    /// Set outline color of the Rectangle
    pub fn set_outline_color(&mut self, color: Color) {
        &self.shape.set_outline_color(color.c);
    }
    /// Set outline thickness of the Rectangle
    pub fn set_outline_thickness(&mut self, size: f32) {
        &self.shape.set_outline_thickness(size);
    }
    /// Set objects position on the Canvas
    pub fn set_position(&mut self, position: (f32, f32)) {
        &self
            .shape
            .set_position(Vector2f::new(position.0, position.1));
    }
    /// Set the size of the object on Canvas
    pub fn set_size(&mut self, size: (f32, f32)) {
        &self.shape.set_size(Vector2f::new(size.0, size.1));
    }
    /// Rotates the object by a given angle from its origin point, which is in its middle by
    /// default.
    pub fn set_rotation(&mut self, angle: f32) {
        &self.shape.set_rotation(360. - angle);
    }
    /// This adds to the objects rotation, unlike ```no_run
    /// set_rotation()``` method which overwrites objects rotation.
    pub fn rotate(&mut self, angle: f32) {
        &self.shape.rotate(angle);
    }
    /// Sets shapes origin point(by default its the top left corner, or objects 0, 0 coordinates).
    /// This is the point, around which objects rotate and which will be used to set objects
    /// position.
    ///
    /// If if you have a Rectangle with the default origin point which is 0, 0 on position x = 320
    /// and y = 180 and width and height of 80 and 100 pixels, valid origin points are coordinates x+width and
    /// y + height.
    pub fn set_origin(&mut self, position: (f32, f32)) {
        &self.shape.set_origin(Vector2f::new(position.0, position.1));
    }

    /// Returns fill color of the object
    pub fn get_fill_color(&self) -> Color {
        let color = Color::from_sfml_color(self.shape.fill_color());

        color
    }
    /// Return the outline color of the object
    pub fn get_outline_color(&self) -> Color {
        let color = Color::from_sfml_color(self.shape.outline_color());

        color
    }
    /// Returns the outline thickness of the object
    pub fn get_outline_thickness(&self) -> f32 {
        self.shape.outline_thickness()
    }
    /// Returns objects size
    pub fn get_size(&self) -> (f32, f32) {
        let size = self.shape.size();

        (size.x, size.y)
    }
    /// Returns objects position on the Canvas
    pub fn get_position(&self) -> (f32, f32) {
        let position = self.shape.position();

        (position.x, position.y)
    }
    /// Returns the angle at which the object is rotated.
    pub fn get_rotation(&self) -> f32 {
        let rotation = self.shape.rotation();

        rotation
    }

    /// Returns the objects origin point.
    pub fn get_origin(&self) -> (f32, f32) {
        let origin = self.shape.origin();

        (origin.x, origin.y)
    }
}

/// Representation of a Circle object.
#[derive(Clone)]
pub struct Circle {
    pub(crate) shape: CircleShape<'static>,
}

impl Circle {
    /// Creates Circle object on given position and with a given radius and Color
    pub fn new(position: (f32, f32), radius: f32, color: Color) -> Self {
        let mut circle = CircleShape::new(radius, 100);

        circle.set_position(Vector2f::new(position.0, position.1));
        circle.set_fill_color(color.c);

        Self { shape: circle }
    }

    /// Creates a new Circle from an existing one
    pub fn from_circle(circle: &Circle) -> Self {
        circle.clone()
    }
}

impl Circle {
    /// Sets object fill color.
    pub fn set_fill_color(&mut self, color: Color) {
        &self.shape.set_fill_color(color.c);
    }

    /// Set objects outline color
    pub fn set_outline_color(&mut self, color: Color) {
        &self.shape.set_outline_color(color.c);
    }

    /// Set objects outline thickness
    pub fn set_outline_thickness(&mut self, size: f32) {
        &self.shape.set_outline_thickness(size);
    }

    /// Set objects outline thickness
    pub fn set_radius(&mut self, radius: f32) {
        &self.shape.set_radius(radius);
    }

    /// Set objects point count.
    /// For example if point count is 3, we get an equilateral triangle.
    pub fn set_point_count(&mut self, pc: u32) {
        &self.shape.set_point_count(pc);
    }

    /// Sets shapes origin point(by default its the top left corner, or objects 0, 0 coordinates).
    /// This is the point, around which objects rotate and which will be used to set objects
    /// position.
    ///
    /// If if you have a Rectangle with the default origin point which is 0, 0 on position x = 320
    /// and y = 180 and width and height of 80 and 100 pixels, valid origin points are coordinates x+width and
    /// y + height.
    pub fn set_origin(&mut self, origin: (f32, f32)) {
        &self.shape.set_origin(Vector2f::new(origin.0, origin.1));
    }

    /// Sets the rotation of the object
    pub fn set_rotation(&mut self, angle: f32) {
        &self.shape.set_rotation(angle);
    }

    /// Adds to objects existing rotation
    pub fn rotate(&mut self, angle: f32) {
        &self.shape.rotate(angle);
    }

    /// Sets objects position on Canvas
    pub fn set_position(&mut self, position: (f32, f32)) {
        &self
            .shape
            .set_position(Vector2f::new(position.0, position.1));
    }

    /// Returns fill color of the object
    pub fn get_fill_color(&self) -> Color {
        let color = Color::from_sfml_color(self.shape.fill_color());

        color
    }
    /// Return the outline color of the object
    pub fn get_outline_color(&self) -> Color {
        let color = Color::from_sfml_color(self.shape.outline_color());

        color
    }
    /// Returns the outline thickness of the object
    pub fn get_outline_thickness(&self) -> f32 {
        self.shape.outline_thickness()
    }
    /// Returns objects radius
    pub fn get_radius(&self) -> f32 {
        let radius = self.shape.radius();

        radius
    }
    /// Returns objects position on the Canvas
    pub fn get_position(&self) -> Option<(f32, f32)> {
        let position = self.shape.position();

        Some((position.x, position.y))
    }
    /// Returns the angle at which the object is rotated.
    pub fn get_rotation(&self) -> f32 {
        let rotation = self.shape.rotation();

        rotation
    }

    /// Returns the objects origin point.
    pub fn get_origin(&self) -> (f32, f32) {
        let origin = self.shape.origin();

        (origin.x, origin.y)
    }

    /// Returns objects point count
    pub fn get_point_count(&self) -> u32 {
        let pc = self.shape.point_count();

        pc
    }
}

/// Representation of multi-point convex shape object.
#[derive(Clone)]
pub struct Polygon {
    pub(crate) shape: ConvexShape<'static>,
}

impl Polygon {
    /// Creates a shape from a vector of coordinates
    pub fn new(points: Vec<(f32, f32)>) -> Self {
        let mut shape = ConvexShape::new(points.len() as u32);
        let mut p_counter = 0u32;
        for point in points.iter() {
            let vec2f = Vector2f::new(point.0, point.1);
            shape.set_point(p_counter, vec2f);
            p_counter += 1;
        }

        Self { shape }
    }

    /// Creates a new shape with the same points and settings
    pub fn from_polygon(polygon: &Polygon) -> Self {
        Self {
            shape: polygon.shape.clone(),
        }
    }
}

impl Polygon {
    /// Sets object fill color.
    pub fn set_fill_color(&mut self, color: Color) {
        &self.shape.set_fill_color(color.c);
    }

    /// Set objects outline color
    pub fn set_outline_color(&mut self, color: Color) {
        &self.shape.set_outline_color(color.c);
    }
    /// Set objects outline thickness
    pub fn set_outline_thickness(&mut self, size: f32) {
        &self.shape.set_outline_thickness(size);
    }
    /// Set objects point count.
    /// For example if point count is 3, we get an equilateral triangle.
    pub fn set_point_count(&mut self, pc: u32) {
        &self.shape.set_point_count(pc);
    }

    /// Sets shapes origin point(by default its the top left corner, or objects 0, 0 coordinates).
    /// This is the point, around which objects rotate and which will be used to set objects
    /// position.
    ///
    /// If if you have a Rectangle with the default origin point which is 0, 0 on position x = 320
    /// and y = 180 and width and height of 80 and 100 pixels, valid origin points are coordinates x+width and
    /// y + height.
    pub fn set_origin(&mut self, origin: (f32, f32)) {
        &self.shape.set_origin(Vector2f::new(origin.0, origin.1));
    }

    /// Sets the rotation of the object
    pub fn set_rotation(&mut self, angle: f32) {
        &self.shape.set_rotation(angle);
    }

    /// Adds to objects existing rotation
    pub fn rotate(&mut self, angle: f32) {
        &self.shape.rotate(angle);
    }

    /// Sets objects position on Canvas
    pub fn set_position(&mut self, position: (f32, f32)) {
        &self
            .shape
            .set_position(Vector2f::new(position.0, position.1));
    }

    /// Returns fill color of the object
    pub fn get_fill_color(&self) -> Color {
        let color = Color::from_sfml_color(self.shape.fill_color());

        color
    }
    /// Return the outline color of the object
    pub fn get_outline_color(&self) -> Color {
        let color = Color::from_sfml_color(self.shape.outline_color());

        color
    }
    /// Returns the outline thickness of the object
    pub fn get_outline_thickness(&self) -> f32 {
        self.shape.outline_thickness()
    }

    /// Returns objects position on the Canvas
    pub fn get_position(&self) -> (f32, f32) {
        let position = self.shape.position();

        (position.x, position.y)
    }
    /// Returns the angle at which the object is rotated.
    pub fn get_rotation(&self) -> f32 {
        let rotation = self.shape.rotation();

        rotation
    }

    /// Returns the objects origin point.
    pub fn get_origin(&self) -> (f32, f32) {
        let origin = self.shape.origin();

        (origin.x, origin.y)
    }

    /// Returns objects point count
    pub fn get_point_count(&self) -> u32 {
        let pc = self.shape.point_count();

        pc
    }
}

#[derive(Clone)]
/// Representation of a Line object
pub struct Line {
    pub(crate) shape: RectangleShape<'static>,
}

impl Line {
    /// Creates a new Line from the coordinates of 2 points, lines thickness and it's color
    pub fn new(point_a: (f32, f32), point_b: (f32, f32), thickness: f32, color: Color) -> Self {
        let mut ret = RectangleShape::new();
        let size = Vector2f::new(thickness, point_b.1 - point_a.1);
        let position = Vector2f::new(point_a.0, point_a.1);
        let angle = 360. - (size.x.powi(2) + size.y.powi(2)).sqrt();

        ret.set_rotation(angle);
        ret.set_position(position);
        ret.set_size(size);
        ret.set_fill_color(color.c);

        Self { shape: ret }
    }

    /// Creates a new line from an existing one
    pub fn from_line(line: &Line) -> Self {
        Self {
            shape: line.shape.clone(),
        }
    }
}

impl Line {
    /// Sets lines thickness
    pub fn set_thickness(&mut self, thickness: f32) {
        let size = self.shape.size();
        self.shape.set_size(Vector2f::new(thickness, size.y));
    }

    /// Sets fill color of the line
    pub fn set_fill_color(&mut self, color: Color) {
        self.shape.set_fill_color(color.c);
    }

    /// Sets lines outline color
    pub fn set_outline_color(&mut self, color: Color) {
        self.shape.set_outline_color(color.c);
    }

    /// Sets lines outline thickness
    pub fn set_outline_thickness(&mut self, thickness: f32) {
        self.shape.set_outline_thickness(thickness);
    }
    /// Returns lines color
    pub fn get_fill_color(&self) -> Color {
        let color = Color::from_sfml_color(self.shape.fill_color());

        color
    }

    /// Returns lines outline color
    pub fn get_outline_color(&self) -> Color {
        let color = Color::from_sfml_color(self.shape.outline_color());

        color
    }

    /// Returns lines outline thickness
    pub fn get_outline_thickness(&self) -> f32 {
        self.shape.outline_thickness()
    }

    /// Returns line thickness
    pub fn get_thickness(&self) -> f32 {
        let vec = self.shape.size();
        vec.x
    }
}

// Text
#[derive(Clone)]
/// Representation of a text that can be displayed onto the Canvas
pub struct Text {
    content: String,
    text_size: u32,
    fill_color: Color,
    outline_color: Option<Color>,
    font_file: Option<FontHandler>,
    position: (f32, f32),
}

// Associated functions
impl Text {
    /// Creates a new Text instance given its contents, size, color and position
    pub fn new(content: &str, text_size: u32, fill_color: Color, position: (f32, f32)) -> Self {
        let c = String::from(content);
        Self {
            content: c,
            text_size,
            fill_color,
            outline_color: None,
            font_file: None,
            position,
        }
    }
}

// Methods
impl Text {
    /// Returns texts contents
    pub fn get_contents(&self) -> String {
        return self.content.clone();
    }

    /// Returns text size
    pub fn get_size(&self) -> u32 {
        let ret = &self.text_size;
        *ret
    }

    /// Returns text color
    pub fn get_fill_color(&self) -> Color {
        self.fill_color
    }

    /// Returns fonts
    pub fn get_font(&self) -> Option<String> {
        match &self.font_file {
            Some(handler) => return Some(handler.get()),
            None => None,
        }
    }

    /// Returns text position on a Canvas
    pub fn get_position(&self) -> (f32, f32) {
        return self.position;
    }

    /// Changes texts contents
    pub fn set_content(&mut self, content: String) {
        self.content = content;
    }

    /// Changes text size
    pub fn set_size(&mut self, size: u32) {
        self.text_size = size;
    }

    /// Changes text color
    pub fn set_fill_color(&mut self, color: Color) {
        self.fill_color = color;
    }

    /// Sets or changes text font.
    /// If there is no font specified, Arial is set as default.
    pub fn set_font(&mut self, font: String) -> Result<(), Error> {
        if let Some(handler) = FontHandler::find_fonts(font) {
            self.font_file = Some(handler);
            Ok(())
        } else {
            return Err(Error::GeneralError("Font file not found!".to_string()));
        }
    }

    /// Changes text position on a Canvas
    pub fn set_position(&mut self, pos: (f32, f32)) {
        self.position = pos;
    }
}

// Button
#[derive(Clone, Copy, PartialEq)]
enum ButtonStyle {
    Rectangle(),
    Circle(),
}
#[derive(Clone)]
/// Representation of a clickable button, that when clicked will execute a function bound to it.
pub struct Button {
    text: Text,
    position: (f32, f32),
    size: (f32, f32),
    func: Option<fn(&mut Canvas, (f32, f32)) -> ()>,
    style: ButtonStyle,
    fill_color: Option<Color>,
    outline_color: Option<Color>,
    outline_thickness: Option<f32>,
}

// Associated functions
impl Button {
    /// Creates a new button object from an existing text object.
    pub fn from_text(mut text: Text, position: (f32, f32), size: (f32, f32)) -> Self {
        text.set_size(size.1 as u32 - size.1 as u32 / 2. as u32);
        text.set_position((position.0 + size.0 / 4., position.1 + size.1 / 5.));
        Self {
            text,
            position,
            size,
            func: None,
            style: ButtonStyle::Rectangle(),
            fill_color: None,
            outline_color: None,
            outline_thickness: None,
        }
    }

    /// Creates a new button object.
    /// Default style is rectangle.
    pub fn new(content: &str, position: (f32, f32), size: (f32, f32)) -> Self {
        Self {
            text: Text::new(
                content,
                size.1 as u32 - size.1 as u32 / 2,
                Color::WHITE,
                (position.0 + size.0 / 4., position.1 + size.1 / 5.),
            ),
            position,
            size,
            func: None,
            style: ButtonStyle::Rectangle(),
            fill_color: None,
            outline_color: None,
            outline_thickness: None,
        }
    }
}

// Methods
impl Button {
    /// Bind the Button to a function.
    /// This function will be called whenever we click the button.
    pub fn bind(&mut self, f: fn(&mut Canvas, (f32, f32)) -> ()) {
        self.func = Some(f);
    }

    /// Sets the style of the button,
    /// Possible arguments: rectangle, circle
    pub fn set_style(&mut self, style: &str) -> Result<(), Error> {
        match style {
            "rectangle" => self.style = ButtonStyle::Rectangle(),
            "circle" => self.style = ButtonStyle::Circle(),
            _ => return Err(Error::GeneralError(format!("{} not a style!", style))),
        }

        Ok(())
    }

    /// Returns true if is bound with some function.
    pub fn is_bound(&self) -> bool {
        if self.func.is_some() {
            return true;
        } else {
            return false;
        }
    }

    /// Sets the fill color of the encompassing shape, which is a rectangle by default.
    pub fn set_fill_color(&mut self, color: Color) {
        self.fill_color = Some(color);
    }
    /// Sets the outline color of the encompassing shape, which is a rectangle by default.
    pub fn set_outline_color(&mut self, color: Color) {
        self.outline_color = Some(color);
    }

    /// Sets the outline thickness of the encompassing shape, which is a rectangle by default.
    /// If this field is None, thickness of 0 is assumed.
    pub fn set_outline_thickness(&mut self, size: f32) {
        self.outline_thickness = Some(size);
    }

    /// Returns an Option containing shapes fill color.
    pub fn get_fill_color(&self) -> Option<Color> {
        match self.fill_color {
            Some(c) => return Some(c),
            None => return None,
        }
    }

    /// Returns an Option containing shapes outline color.
    pub fn get_outline_color(&self) -> Option<Color> {
        match self.outline_color {
            Some(c) => return Some(c),
            None => return None,
        }
    }

    /// Returns an Option containing shapes outline thickness.
    /// Return value is f32.
    pub fn get_outline_thickness(&self) -> f32 {
        self.outline_thickness.unwrap_or(0f32)
    }

    /// Sets the size of the encompassing shape
    pub fn set_size(&mut self, size: (f32, f32)) {
        self.size = size;
    }

    /// Returns the size of the encompassing shape
    pub fn get_size(&self) -> (f32, f32) {
        self.size
    }

    /// Set the position of button
    pub fn set_position(&mut self, pos: (f32, f32)) {
        self.position = pos;

        self.text.set_position((
            pos.0 - self.text.get_size() as f32,
            pos.1 - self.text.get_size() as f32,
        ));
    }

    /// Return button position
    pub fn get_position(&self) -> (f32, f32) {
        self.position
    }

    /// Returns the color of the text
    pub fn get_text_color(&self) -> Color {
        self.text.get_fill_color()
    }

    /// Sets the color of the text
    pub fn set_text_color(&mut self, c: Color) {
        self.text.set_fill_color(c);
    }
}

/// A struct representing an arc, a curved line
pub struct Arc {
    pub(crate) point_count: u32,
    pub(crate) shape: ConvexShape<'static>,
}