First comparison operator for the code view

Author: markusmoenig

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "theframework"
-version = "0.1.16"
+version = "0.1.17"
 edition = "2021"
 description = "A cross platform application UI framework."
 license = "MIT"
@@ -16,7 +16,7 @@ maths-rs = { version = "0.2", features = ["short_types", "short_hand_constructor
 pixels = { version = "0.13.0", optional = true }
 winit = { version = "0.28.7", optional = true }
 winit_input_helper = { version = "0.14.1", optional = true }
-therenderer = { version = "0.1.1", optional = true }
+#therenderer = { version = "0.1.1", optional = true }
 # therenderer = { path = "../therenderer", optional = true }
 rust-embed = { version = "8", default-features = true, features = ["include-exclude"] }
 png = "0.17.8"
@@ -47,7 +47,7 @@ wasm-bindgen-futures = "0.4"
 web-sys = { version = "0.3", features = ["GpuTextureFormat"] }
 
 [features]
-renderer = ["therenderer"]
+#renderer = ["therenderer"]
 ui = ["futures", "rfd", "flate2", "rayon"]
 code = []
 pixels_winit = ["pixels", "winit", "winit_input_helper"]

Readme.md

@@ -31,10 +31,6 @@ The **code** option adds a unique and powerful visual scripting system to TheFra
 * Easy-to-use via drag and drop.
 * Very fast as it compiles to native closures.
 
-### Option: renderer
-
-A fast state-based 2D renderer supporting varuous shapes and text. The development of the *renderer* option is currently on hold to focus on the *ui* first.
-
 ### Current Backends
 
 * *Desktops* via [pixels](https://github.com/parasyte/pixels) and [winit](https://github.com/rust-windowing/winit). This is the default backend.

examples/circle/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-theframework = { path = "../..", features = ["renderer"] }
+theframework = { path = "../..", features = [] }
 lazy_static = "1.4.0"
 
 [lib]

examples/circle/Readme.md

@@ -1,51 +1 @@
-# Circle
-
-Draws and moves a circle based on user input.
-
-## Running on the Desktop
-
-```bash
-cargo run --release --package circle
-```
-
-Will run the example on the Desktop utilizing pixels and winit.
-
-## Running on the Web
-
-Install the WASM32 target:
-
-```bash
-rustup target add wasm32-unknown-unknown
-```
-
-Build the project and start a local server to host it:
-
-```bash
-cargo run-wasm --release --package circle
-```
-
-Open http://localhost:8000/ in your browser to run the example.
-
-To build the project without serving it:
-
-```bash
-cargo run-wasm --release --build-only --package circle
-```
-
-## Building for Xcode
-
-To build for Xcode you need to uncomment the last three lines in the Cargo.toml file of the Circle example:
-
-```toml
-[lib]
-name = "rustapi"
-crate-type = ["staticlib"]
-```
-
-and than build to a static lib via
-
-```bash
-cargo build --release --package circle
-```
-
-Copy the resulting librust.a lib to the Xcode/TheFramework folder, open the project in Xcode and run or deploy it.
+Simple example of using TheFramework without any enabled features, i.e. just a window in which we draw a white circle.

examples/circle/src/circle.rs

@@ -1,62 +1,44 @@
 use theframework::prelude::*;
 
-pub struct Circle {
-    circle_id: u32,
-}
+pub struct Circle {}
 
 impl TheTrait for Circle {
     fn new() -> Self
     where
         Self: Sized,
     {
-        Self { circle_id: 0 }
-    }
-
-    /// Init the scene by adding a shape to the world space
-    fn init(&mut self, ctx: &mut TheContext) {
-        // The world space always has the id of 0
-        if let Some(world_space) = ctx.renderer.get_space_mut(0) {
-            world_space.set_coord_system(Center);
-            self.circle_id = world_space.add_shape(Disc);
-            world_space.set_shape_property(self.circle_id, Normal, Color, vec![1.0, 1.0, 1.0, 1.0]);
-            world_space.set_shape_property(self.circle_id, Normal, Radius, vec![100.0]);
-            world_space.set_shape_property(
-                self.circle_id,
-                Selected,
-                Color,
-                vec![1.0, 0.0, 0.0, 1.0],
-            );
-            world_space.set_shape_property(self.circle_id, Selected, Radius, vec![120.0]);
-        }
+        Self {}
     }
 
     /// Draw a circle in the middle of the window
     fn draw(&mut self, pixels: &mut [u8], ctx: &mut TheContext) {
-        ctx.renderer.draw(pixels, ctx.width, ctx.height);
+        ctx.draw.rect(
+            pixels,
+            &(0, 0, ctx.width, ctx.height),
+            ctx.width,
+            &[0, 0, 0, 255],
+        );
+        ctx.draw.circle(
+            pixels,
+            &(ctx.width / 2 - 100, ctx.height / 2 - 100, 200, 200),
+            ctx.width,
+            &[255, 255, 255, 255],
+            100.0,
+        )
     }
 
-    /// If the touch event is inside the circle, set the circle state to Selected
-    fn touch_down(&mut self, x: f32, y: f32, ctx: &mut TheContext) -> bool {
-        if let Some(world_space) = ctx.renderer.get_space_mut(0) {
-            if let Some(shape_id) = world_space.get_shape_at(x, y) {
-                world_space.set_shape_state(shape_id, Selected);
-            } else {
-                world_space.set_shape_state(self.circle_id, Normal);
-            }
-        }
-        ctx.renderer.needs_update()
+    /// Touch down event
+    fn touch_down(&mut self, _x: f32, _y: f32, _ctx: &mut TheContext) -> bool {
+        false
     }
 
-    /// Set the circle state to Selected.
-    fn touch_up(&mut self, _x: f32, _y: f32, ctx: &mut TheContext) -> bool {
-        if let Some(world_space) = ctx.renderer.get_space_mut(0) {
-            world_space.set_shape_state(self.circle_id, Normal);
-        }
-        ctx.renderer.needs_update()
+    /// Touch up event
+    fn touch_up(&mut self, _x: f32, _y: f32, _ctx: &mut TheContext) -> bool {
+        false
     }
 
-    /// Query if the renderer needs an update (tramsition animation ongoing etc.)
-    fn update(&mut self, ctx: &mut TheContext) -> bool {
-        ctx.renderer.needs_update()
+    /// Query if the widget needs a redraw
+    fn update(&mut self, _ctx: &mut TheContext) -> bool {
+        false
     }
 }

examples/codeeditor/src/editor.rs

@@ -182,10 +182,12 @@ impl TheTrait for CodeEditor {
 
                                         sandbox.insert_module(module.clone());
                                         module.execute(&mut sandbox);
+                                        code_view.set_compiled(true);
                                         code_view.set_debug_module(
                                             sandbox.get_module_debug_module(module.id),
                                         );
                                     } else {
+                                        code_view.set_compiled(false);
                                         code_view.set_debug_module(TheDebugModule::new());
                                     }
                                 }

src/thecode/thecodeatom.rs

@@ -5,6 +5,7 @@ use super::thecodenode::TheCodeNodeData;
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 pub enum TheCodeAtom {
     Assignment(String),
+    Comparison(String),
     Value(TheValue),
     Add,
     Multiply,
@@ -20,20 +21,20 @@ pub enum TheCodeAtom {
     Return,
     EndOfExpression,
     EndOfCode,
-    Switch,
-    CaseCondition,
-    CaseBody,
 }
 
 impl TheCodeAtom {
     pub fn uneven_slot(&self) -> bool {
-        matches!(self, TheCodeAtom::Assignment(_name))
+        matches!(self, TheCodeAtom::Assignment(_))
+            || matches!(self, TheCodeAtom::Comparison(_))
             || matches!(self, TheCodeAtom::Add)
             || matches!(self, TheCodeAtom::Multiply)
     }
 
     pub fn can_assign(&self) -> bool {
-        matches!(self, TheCodeAtom::LocalSet(_name))
+        matches!(self, TheCodeAtom::LocalSet(_))
+            || matches!(self, TheCodeAtom::ObjectSet(_, _))
+            || matches!(self, TheCodeAtom::Pulse)
     }
 
     pub fn from_json(json: &str) -> Self {
@@ -46,6 +47,43 @@ impl TheCodeAtom {
 
     pub fn to_node(&self, ctx: &mut TheCompilerContext) -> TheCodeNode {
         match self {
+            TheCodeAtom::Comparison(_) => {
+                let call: TheCodeNodeCall =
+                    |_stack: &mut Vec<TheValue>,
+                     data: &mut TheCodeNodeData,
+                     sandbox: &mut TheCodeSandbox| {
+                        if let Some(f) = data.sub_functions.first_mut() {
+                            if let Some(v) = f.execute(sandbox).pop() {
+                                if data.values[0] == v {
+                                    println!("yes");
+                                    if data.sub_functions.len() > 1 {
+                                        _ = data.sub_functions[1].execute(sandbox).pop();
+                                    }
+                                }
+
+                                println!("Comparison: left {:?}, right: {:?}", data.values[0], v);
+                            }
+                        }
+
+                        TheCodeNodeCallResult::Continue
+                    };
+
+                let mut node = TheCodeNode::new(
+                    call,
+                    TheCodeNodeData::location_values(ctx.node_location, vec![TheValue::Int(0)]),
+                );
+
+                if let Some(function) = ctx.remove_function() {
+                    // let mut sandbox = TheCodeSandbox::new();
+                    // if let Some(v) = function.execute(&mut sandbox).pop() {
+                    //     println!("{:?}", v);//
+                    //     node.data.values[1] = v;
+                    // }
+                    node.data.sub_functions.push(function);
+                }
+
+                node
+            }
             // Generates a pulse gate.
             TheCodeAtom::Pulse => {
                 let call: TheCodeNodeCall =
@@ -98,7 +136,7 @@ impl TheCodeAtom {
 
                 node
             }
-            TheCodeAtom::Assignment(_op) => {
+            TheCodeAtom::Assignment(_) => {
                 let call: TheCodeNodeCall =
                     |_stack: &mut Vec<TheValue>,
                      _data: &mut TheCodeNodeData,
@@ -390,7 +428,6 @@ impl TheCodeAtom {
                      _sandbox: &mut TheCodeSandbox| {
                         if let Some(b) = stack.pop() {
                             if let Some(a) = stack.pop() {
-                                println!("t {:?} {:?}", a, b);
                                 if let Some(result) = TheValue::add(&a, &b) {
                                     stack.push(result);
                                 } else {
@@ -438,33 +475,6 @@ impl TheCodeAtom {
                     };
                 TheCodeNode::new(call, TheCodeNodeData::location(ctx.current_location))
             }
-            TheCodeAtom::Switch => {
-                let call: TheCodeNodeCall =
-                    |_stack: &mut Vec<TheValue>,
-                     _data: &mut TheCodeNodeData,
-                     _sandbox: &mut TheCodeSandbox| {
-                        TheCodeNodeCallResult::Continue
-                    };
-                TheCodeNode::new(call, TheCodeNodeData::location(ctx.current_location))
-            }
-            TheCodeAtom::CaseCondition => {
-                let call: TheCodeNodeCall =
-                    |_stack: &mut Vec<TheValue>,
-                     _data: &mut TheCodeNodeData,
-                     _sandbox: &mut TheCodeSandbox| {
-                        TheCodeNodeCallResult::Continue
-                    };
-                TheCodeNode::new(call, TheCodeNodeData::location(ctx.current_location))
-            }
-            TheCodeAtom::CaseBody => {
-                let call: TheCodeNodeCall =
-                    |_stack: &mut Vec<TheValue>,
-                     _data: &mut TheCodeNodeData,
-                     _sandbox: &mut TheCodeSandbox| {
-                        TheCodeNodeCallResult::Continue
-                    };
-                TheCodeNode::new(call, TheCodeNodeData::location(ctx.current_location))
-            }
         }
     }
 
@@ -485,9 +495,18 @@ impl TheCodeAtom {
         }
     }
 
+    pub fn to_color(&self) -> [u8; 4] {
+        match self {
+            Self::ObjectSet(_, _) => [36, 61, 92, 255],
+            //[87, 112, 143, 255]
+            _ => [174, 174, 174, 255],
+        }
+    }
+
     pub fn to_kind(&self) -> TheCodeAtomKind {
         match self {
             TheCodeAtom::Assignment(_op) => TheCodeAtomKind::Equal,
+            TheCodeAtom::Comparison(_op) => TheCodeAtomKind::Equal,
             TheCodeAtom::FuncDef(_name) => TheCodeAtomKind::Fn,
             TheCodeAtom::FuncArg(_name) => TheCodeAtomKind::Identifier,
             TheCodeAtom::FuncCall(_name) => TheCodeAtomKind::Identifier,
@@ -503,15 +522,13 @@ impl TheCodeAtom {
             TheCodeAtom::Multiply => TheCodeAtomKind::Star,
             TheCodeAtom::EndOfExpression => TheCodeAtomKind::Semicolon,
             TheCodeAtom::EndOfCode => TheCodeAtomKind::Eof,
-            TheCodeAtom::Switch => TheCodeAtomKind::If,
-            TheCodeAtom::CaseCondition => TheCodeAtomKind::If,
-            TheCodeAtom::CaseBody => TheCodeAtomKind::If,
         }
     }
 
     pub fn describe(&self) -> String {
         match self {
             TheCodeAtom::Assignment(op) => op.clone(),
+            TheCodeAtom::Comparison(op) => op.clone(),
             TheCodeAtom::FuncDef(name) => name.clone(),
             TheCodeAtom::FuncArg(name) => name.clone(),
             TheCodeAtom::FuncCall(name) => name.clone(),
@@ -530,15 +547,13 @@ impl TheCodeAtom {
             TheCodeAtom::Multiply => "*".to_string(),
             TheCodeAtom::EndOfExpression => ";".to_string(),
             TheCodeAtom::EndOfCode => "Stop".to_string(),
-            TheCodeAtom::Switch => "Switch".to_string(),
-            TheCodeAtom::CaseCondition => "Case".to_string(),
-            TheCodeAtom::CaseBody => ":".to_string(),
         }
     }
 
     pub fn help(&self) -> String {
         match self {
             TheCodeAtom::Assignment(name) => format!("Assignment ({}).", name),
+            TheCodeAtom::Comparison(name) => format!("Comparison ({}).", name),
             TheCodeAtom::FuncDef(name) => format!("Function definition ({}).", name),
             TheCodeAtom::FuncArg(name) => format!("Function argument ({}).", name),
             TheCodeAtom::FuncCall(name) => format!(
@@ -581,9 +596,6 @@ impl TheCodeAtom {
             TheCodeAtom::Multiply => "Operator ('*')".to_string(),
             TheCodeAtom::EndOfExpression => ";".to_string(),
             TheCodeAtom::EndOfCode => "Stop".to_string(),
-            TheCodeAtom::Switch => "Switch statement.".to_string(),
-            TheCodeAtom::CaseCondition => "Switch 'Case' statement.".to_string(),
-            TheCodeAtom::CaseBody => "Switch 'Case' body.".to_string(),
         }
     }