rqml/src/main.rs

use orbtk::prelude::*;
use rhai::{packages::*, Engine, EvalAltResult, INT};
extern crate pest;
#[macro_use]
extern crate pest_derive;

use crate::Value::{QmlIdent, QmlNumber, QmlString};
use pest::iterators::{Pair, Pairs};
use pest::Parser;
use std::borrow::Borrow;
use std::fs::read_to_string;

#[derive(Parser)]
#[grammar = "../pest/qml.pest"]
struct QmlParser;

#[derive(Debug, Clone)]
enum Value {
    QmlString(String),
    QmlNumber(f64),
    QmlIdent(String),
}

#[derive(Debug, Clone)]
struct QML {
    properties: HashMap<String, Value>,
    children: Vec<(String, QML)>,
}

fn parse_qml(qml: Pairs<Rule>) -> QML {
    let mut qmldoc = QML {
        properties: Default::default(),
        children: vec![],
    };
    for pair in qml {
        //   println!("Rule {:?} Str {}", pair.as_rule(), pair.as_str());

        match pair.as_rule() {
            Rule::import => {
                let mut tokens = pair.into_inner();
                println!("Found new Import {} ", tokens.next().unwrap().as_str());
            }
            Rule::body => {
                let mut tokens = pair.into_inner();
                let ident = tokens.next().unwrap().as_str();
                println!("Found new Body: {} ", ident);
                qmldoc
                    .children
                    .push((String::from(ident), parse_qml(tokens.into_iter())));
            }
            Rule::property => {
                let mut tokens = pair.into_inner();
                let ident = tokens.next().unwrap().as_str();
                let value = tokens.next().unwrap();
                // let value = tokens.next().unwrap().as_str();
                match value.as_rule() {
                    Rule::number => {
                        let num: f64 = value.as_str().parse().unwrap();
                        println!("Found new Property: {} {:?}", ident, num);
                        qmldoc
                            .properties
                            .insert(String::from(ident), QmlNumber(num));
                    }
                    Rule::string => {
                        println!("Found new Property: {} {}", ident, value.as_str());
                        qmldoc.properties.insert(
                            String::from(ident),
                            QmlString(String::from(value.into_inner().next().unwrap().as_str())),
                        );
                    }
                    Rule::ident => {
                        println!("Found new Property: {} {}", ident, value.as_str());
                        qmldoc
                            .properties
                            .insert(String::from(ident), QmlIdent(String::from(value.as_str())));
                    }
                    _ => {}
                }
            }
            Rule::function => {
                let mut tokens = pair.into_inner();
                let ident = tokens.next().unwrap().as_str();
                let value = tokens.concat();
                qmldoc.properties.insert(
                    String::from(ident),
                    QmlString(String::from(value.clone().trim())),
                );
            }
            _ => return parse_qml(pair.into_inner()),
        }
    }
    qmldoc
}

fn main() {
    Application::new()
        .window(|ctx| {
            let qml = read_to_string("./res/example.qml").unwrap();
            let qml_tokens = QmlParser::parse(Rule::qml, qml.as_str()).unwrap_or_else(|e| panic!("{}", e));
            let qml_doc = parse_qml(qml_tokens);
            let top_level = qml_doc.children.clone();

            let width = match top_level[0].1.properties.get("width") {
                Some(QmlNumber(num)) => num.clone(),
                _ => 600.0,
            };
            let height = match top_level[0].1.properties.get("height") {
                Some(QmlNumber(num)) => num.clone(),
                _ => 600.0,
            };
            println!("{:?}", qml_doc);
            Window::create()
                .title("QML")
                .position((100.0, 100.0))
                .resizeable(true)
                .size(width, height)
                .child(render_ctx(ctx, &top_level, 0, 0, &HashMap::new()).unwrap())
                .build(ctx)
        })
        .run();
}

fn parse_number(val: Option<&Value>, env: &HashMap<String, Value>) -> f64 {
    match val {
        Some(QmlNumber(num)) => num.clone(),
        Some(QmlIdent(ident)) => match env.get(ident) {
            Some(QmlNumber(num)) => num.clone(),
            _ => 0.0,
        },
        _ => 0.0,
    }
}

fn render_ctx(
    ctx: &mut BuildContext,
    qml: &Vec<(String, QML)>,
    row: u32,
    col: u32,
    env: &HashMap<String, Value>,
) -> Option<Entity> {
    for (ident, child) in qml.iter() {
        match ident.as_str() {
            "Grid" => {
                let mut grid = Grid::create();
                grid = grid.attach(Grid::row(row as usize));
                grid = grid.attach(Grid::column(col as usize));
                let rows = parse_number(child.properties.get("rows"), &env) as u32;
                let cols = parse_number(child.properties.get("cols"), &env) as u32;

                let mut grid_rows = Rows::create();
                for i in 0..rows {
                    grid_rows = grid_rows.row("stretch");
                }
                grid = grid.rows(grid_rows.build());

                let mut grid_cols = Columns::create();
                for i in 0..rows {
                    grid_cols = grid_cols.column("stretch");
                }
                grid = grid.columns(grid_cols.build());

                let mut grow = 0u32;
                let mut gcol = 0u32;
                //rect = rect.attach(Grid::column(gcol as usize));
                for (i, s) in child.children.iter() {
                    match render_ctx(ctx, &vec![(i.clone(), s.clone())], grow, gcol, &env) {
                        Some(entity) => {
                            grid = grid.child(entity);
                            grow += 1;
                            if grow as u32 == rows {
                                grow = 0;
                                gcol += 1;
                            }
                        }
                        _ => {}
                    }
                }

                return Some(grid.build(ctx));
            }
            "Rectangle" => {
                let width = parse_number(child.properties.get("width"), &env);
                let height = parse_number(child.properties.get("height"), &env);

                let color = match child.properties.get("color") {
                    Some(QmlString(col)) => match col.as_str() {
                        "red" => Color::rgb(0xff, 00, 00),
                        "blue" => Color::rgb(0x00, 00, 0xff),
                        _ => Color::rgb(0xff, 0xff, 0xff),
                    },
                    _ => Color::rgb(0xff, 0xff, 0xff),
                };
                let mut rect = Container::create()
                    //  .width(width)
                    // .height(height)
                    .background(color);

                rect = rect.attach(Grid::row(row as usize));
                rect = rect.attach(Grid::column(col as usize));

                let mut env = env.clone();
                env.insert(String::from("parent.width"), QmlNumber(width));
                env.insert(String::from("parent.height"), QmlNumber(height));

                for (i, s) in child.children.iter() {
                    match render_ctx(ctx, &vec![(i.clone(), s.clone())], 0, 0, &env) {
                        Some(entity) => {
                            rect = rect.child(entity);
                        }
                        _ => {}
                    }
                }

                return Some(rect.build(ctx));
            }
            "Button" => {
                let mut button = Button::create();
                button = button.attach(Grid::row(row as usize));
                button = button.attach(Grid::column(col as usize));

                let code = match child.properties.get("onclick").unwrap() {
                    QmlString(code) => code.clone(),
                    _ => String::new(),
                };
                button = button.on_click(move |x, y| -> bool {
                    rhai_script(code.clone());
                    return true;
                });

                let text = match child.properties.get("text").unwrap() {
                    QmlString(text) => text.clone(),
                    _ => String::new(),
                };

                match child.properties.get("anchors.centerIn") {
                    Some(QmlIdent(str)) => {
                        if str.eq("parent") {
                            button = button.vertical_alignment(Alignment::Center);
                            button = button.horizontal_alignment(Alignment::Center);
                        }
                    }
                    _ => {}
                }
                button = button.text(text);

                return Some(button.build(ctx));
            }
            "Text" => {
                let text = match child.properties.get("text").unwrap() {
                    QmlString(text) => text.clone(),
                    _ => String::new(),
                };

                let mut tt = TextBlock::create();
                tt = tt.text(text);
                tt = tt.attach(Grid::row(row as usize));
                tt = tt.attach(Grid::column(col as usize));

                match child.properties.get("anchors.centerIn") {
                    Some(QmlIdent(str)) => {
                        if str.eq("parent") {
                            tt = tt.vertical_alignment(Alignment::Center);
                            tt = tt.horizontal_alignment(Alignment::Center);
                        }
                    }
                    _ => {}
                }

                return Some(tt.build(ctx));
            }
            _ => println!("unknown ident {}", ident),
        }
    }
    None
}

fn rhai_script(run: String) {
    let mut engine = Engine::new();
    engine.eval::<()>(run.as_str());
}