#[derive(Debug)]

pub struct FixedScale {
    x_max:          f32,
    x_min:          f32,
    y_max:          f32,
    y_min:          f32,

pub enum Scale {
    Group {
        x_min:  f32,
        x_max:  f32,
        y_min:  f32,
        y_max:  f32,
    },
    Single {
        x_min:  f32,
        x_max:  f32,
        y_min:  f32,
        y_max:  f32,
    },

    pub fn into_ui_data(&self) -> Result<UIData, Error> {

    pub fn into_data(&self) -> Result<UIData, Error> {

    sized:      Option<FixedScale>,

    scale:      Scale,

}
pub struct GraphicBuilder {
    lines:  Vec<LineJson>,
    x_min:  Option<f32>,
    x_max:  Option<f32>,
    y_min:  Option<f32>,
    y_max:  Option<f32>,

impl GraphicBuilder {
    // Update if required
    fn x_min(&mut self, x: f32) {
        match self.x_min {
            None        => self.x_min = Some(x),
            Some(old)   => if x < old { self.x_min = Some(x) },
        }
    }
    // Update if required
    fn x_max(&mut self, x: f32) {
        match self.x_max {
            None        => self.x_min = Some(x),
            Some(old)   => if x > old { self.x_max = Some(x) },
        }
    }

    // Update if required
    fn y_min(&mut self, y: f32) {
        match self.y_min {
            None        => self.y_min = Some(y),
            Some(old)   => if y < old { self.y_min = Some(y) },
        }
    }
    // Update if required
    fn y_max(&mut self, y: f32) {
        match self.y_max {
            None        => self.y_min = Some(y),
            Some(old)   => if y > old { self.y_max = Some(y) },
        }
    }
    fn scale(&self) -> Scale {
        Scale::Single {
            x_min: self.x_min.unwrap(),
            x_max: self.x_max.unwrap(),
            y_min: self.y_min.unwrap(),
            y_max: self.y_max.unwrap(),
        }
    }
}
#[derive(Debug)]

        kt.to_ref().try_into().map_err(|err: keytree::error::Error| {

        dbg!(&kt);
        let out = kt.to_ref().try_into().map_err(|err: keytree::error::Error| {

        }) 

        });
        out

            // GraphicJson builder
            let mut graphic_json = GraphicJson {
                country:    *country,
                index:      *index,
                lines:      Vec::new(),
                sized:      None,

            dbg!((country, index));
            let mut graphic_json_builder = GraphicBuilder {
                lines:  Vec::new(),
                x_min:  None,
                x_max:  None,
                y_min:  None,
                y_max:  None,

                let x_min = x_rts.min(0);
                let x_max = x_rts.max(0);

                let y_min = y_rts.min(0);
                let y_max = y_rts.max(0);

                graphic_json.lines.push(line_json);

                graphic_json_builder.lines.push(line_json);
                graphic_json_builder.x_min(x_min);
                graphic_json_builder.x_max(x_max);
                graphic_json_builder.y_min(y_min);
                graphic_json_builder.y_max(y_max);

            let graphic_json = GraphicJson {
                country:    *country,
                index:      *index,
                scale:      graphic_json_builder.scale(),
                lines:      graphic_json_builder.lines,
            };

            Spec(self.vec_at("ui_spec::ui_graphic")?)

            Spec(self.vec_at("ui_spec::graphic")?)

#[derive(Debug)]

#[derive(Debug)]