syntaxAlchemist/lib-nested
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Activity

Compare commits

base: syntaxAlchemist:73d457ba24f3008836ce2ab6886ab5b9162720d4
Branches Tags
syntaxAlchemist:dev
syntaxAlchemist:refactor2
syntaxAlchemist:wip
syntaxAlchemist:refactor
syntaxAlchemist:topic-sdf
..
compare: syntaxAlchemist:97a5b580dfd7454d87e8c699cf5c6033fa259b27
Branches Tags
syntaxAlchemist:refactor2
syntaxAlchemist:wip
syntaxAlchemist:refactor
syntaxAlchemist:dev
syntaxAlchemist:topic-sdf

No commits in common. "73d457ba24f3008836ce2ab6886ab5b9162720d4" and "97a5b580dfd7454d87e8c699cf5c6033fa259b27" have entirely different histories.
73d457ba24 ... 97a5b580df

21 changed files with 319 additions and 419 deletions
Show stats Expand all files Collapse all files

5
display-server-tty/Cargo.toml
View file

@ -1,12 +1,11 @@
[package] [package]
authors = ["Michael Sippel <micha@fragmental.art>"] authors = ["Michael Sippel <micha@fragmental.art>"]
name = "display-server-tty" name = "display_server"
version = "0.1.0" version = "0.1.0"
edition = "2018" edition = "2018"
[dependencies] [dependencies]
nested = { path = "../lib-nested-core" } nested = { path = "../../nested" }
nested-tty = { path = "../lib-nested-tty" }
termion = "1.5.5" termion = "1.5.5"
cgmath = { version = "0.18.0", features = ["serde"] } cgmath = { version = "0.18.0", features = ["serde"] }
serde = { version = "1.0", features = ["serde_derive"] } serde = { version = "1.0", features = ["serde_derive"] }

1
examples/tty-02-node/Cargo.toml
View file

@ -6,7 +6,6 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies] [dependencies]
laddertypes = { path = "../../../lib-laddertypes" }
r3vi = { path = "../../../lib-r3vi" } r3vi = { path = "../../../lib-r3vi" }
nested = { path = "../../lib-nested-core" } nested = { path = "../../lib-nested-core" }
nested-tty = { path = "../../lib-nested-tty" } nested-tty = { path = "../../lib-nested-tty" }

194
examples/tty-02-node/src/main.rs
View file

@ -9,12 +9,11 @@ use {
nested::{ nested::{
editors::ObjCommander, editors::ObjCommander,
repr_tree::{Context, ReprTree}, repr_tree::{Context, ReprTree},
edit_tree::{EditTree} edit_tree::{NestedNode}
}, },
nested_tty::{ nested_tty::{
DisplaySegment, TTYApplication, DisplaySegment, TTYApplication,
TerminalCompositor, TerminalStyle, TerminalView, TerminalCompositor, TerminalStyle, TerminalView,
TerminalAtom
}, },
r3vi::{ r3vi::{
buffer::{singleton::*, vec::*}, buffer::{singleton::*, vec::*},
@ -22,101 +21,112 @@ use {
std::sync::{Arc, RwLock}, std::sync::{Arc, RwLock},
}; };
/*
struct ParseDigit { radix: u32 }
impl Morphism for ParseDigit {
fn new(
ctx: &Arc<RwLock<Context>>
) -> Self {
}
fn setup_projection(&self, repr_tree: Arc<RwLock<ReprTree>>) {
if let Some( char_view ) = repr_tree.get_out(Context::parse(&ctx, "Char~")) {
}
}
}
get_morphism( ) -> Morphism {
}
*/
#[async_std::main] #[async_std::main]
async fn main() { async fn main() {
/* setup context & create Editor-Tree /* setup context & create Editor-Tree
*/ */
let ctx = Arc::new(RwLock::new(Context::new())); let ctx = Arc::new(RwLock::new(Context::new()));
nested::editors::char::init_ctx( ctx.clone() ); /* Create a Char-Node with editor & view
nested::editors::integer::editor::init_ctx( ctx.clone() ); */
nested::editors::list::init_ctx( ctx.clone() );
let char_type = Context::parse(&ctx, "Char"); let mut char_obj = ReprTree::make_leaf(
let digit_type = Context::parse(&ctx, "<Digit Radix>"); Context::parse(&ctx, "Char"),
let list_type = Context::parse(&ctx, "<List Item>"); SingletonBuffer::new('X').get_port().into()
let posint_type = Context::parse(&ctx, "<PosInt Radix>"); );
let item_tyid = ctx.read().unwrap().get_var_typeid("Item").unwrap(); /*
char_obj.insert_branch(
ctx.write().unwrap().meta_chars.push(','); Context::parse(&ctx, "EditTree"),
ctx.write().unwrap().meta_chars.push('\"'); SingletonBuffer::new(
ctx.write().unwrap().set_edittree_hook( NestedNode::new()
Arc::new(
move |et: Arc<RwLock<EditTree>>, t: laddertypes::TypeTerm| {
if let Ok(σ) = laddertypes::unify(&t, &char_type.clone()) {
let mut et = et.write().unwrap();
*et = nested_tty::editors::edittree_make_char_view(et.clone());
}
else if let Ok(σ) = laddertypes::unify(&t, &digit_type) {
let mut et = et.write().unwrap();
*et = nested_tty::editors::edittree_make_digit_view(et.clone());
}
else if let Ok(σ) = laddertypes::unify(&t, &posint_type) {
let mut et = et.write().unwrap();
nested_tty::editors::list::PTYListStyle::for_node( &mut *et, ("0d", "", ""));
nested_tty::editors::list::PTYListController::for_node( &mut *et, None, None );
}
else if let Ok(σ) = laddertypes::unify(&t, &list_type) {
let mut et = et.write().unwrap();
let item_type = σ.get( &laddertypes::TypeID::Var(item_tyid) ).unwrap();
if item_type == &char_type {
nested_tty::editors::list::PTYListStyle::for_node( &mut *et, ("\"", "", "\""));
nested_tty::editors::list::PTYListController::for_node( &mut *et, None, Some('\"') );
} else {
nested_tty::editors::list::PTYListStyle::for_node( &mut *et, ("{", ", ", "}"));
nested_tty::editors::list::PTYListController::for_node( &mut *et, Some(','), Some('}') );
}
//*et = nested_tty::editors::edittree_make_list_edit(et.clone());
}
}
) )
); );
/* structure of Repr-Tree let mut vec_obj = ReprTree::make_leaf(
* Context::parse(&ctx, "<Vec Char>"),
* === Repr-Tree === VecBuffer::new(vec!['a', 'b', 'c']).get_port().into()
* );
* <Digit 10>
* / | \
* / | \
* / | \
* u32 [ EditTree ] Char
* - Editor \
* - Display [ EditTree ]
* / | \ - Editor
* / | \ - Display
* TTY PixelBuf SDF / | \
* / | \
* TTY PixelBuf SDF
*/
let rt_digit = ReprTree::new_arc( Context::parse(&ctx, "<Digit 16>") );
/* add initial representation let mut char_edit = Context::new_edit_tree(
* <Digit 16> ~ Char &ctx,
*/ // node type
rt_digit.write().unwrap() Context::parse(&ctx, "Char"),
.insert_leaf( // depth
vec![ Context::parse(&ctx, "Char") ].into_iter(), SingletonBuffer::new(0).get_port(),
SingletonBuffer::new('x').get_port().into() )
); .unwrap();
*/
// add a display view to the node
//node1 = nested_tty::editors::node_make_tty_view(node1);
/* setup TTY-Display for DigitEditor /* Create a <List Char>-Node with editor & view
*/ */
let edittree_digit = ctx.read().unwrap().setup_edittree(rt_digit.clone(), r3vi::buffer::singleton::SingletonBuffer::new(0).get_port());
//--- /*
let rt_string = ReprTree::new_arc( Context::parse(&ctx, "<List <List Char>>") ); let mut node2 = Context::make_node(
let edittree = ctx.read().unwrap().setup_edittree(rt_string.clone(), r3vi::buffer::singleton::SingletonBuffer::new(0).get_port()); &ctx,
// node type
Context::parse(&ctx, "<List Char>"),
// depth
SingletonBuffer::new(0).get_port(),
)
.unwrap();
*/
// add a display view to the node
//node2 = nested_tty::editors::node_make_tty_view(node2);
/* Create a <List Char>-Node with editor & view
*/
/*
let mut node3 = Context::make_node(
&ctx,
// node type
Context::parse(&ctx, "<List <List Char>>"),
// depth
SingletonBuffer::new(0).get_port(),
)
.unwrap();
*/
// add a display view to the node
//node3 = nested_tty::editors::node_make_tty_view(node3);
/* setup terminal /* setup terminal
*/ */
let app = TTYApplication::new({ let app = TTYApplication::new({
/* event handler /* event handler
*/ */
let ctx = ctx.clone(); let ctx = ctx.clone();
let et1 = edittree.clone(); // let node1 = node1.clone();
// let node2 = node2.clone();
// let node3 = node3.clone();
move |ev| { move |ev| {
et1.write().unwrap().send_cmd_obj(ev.to_repr_tree(&ctx)); // let mut node1 = node1.clone();
// let mut node2 = node2.clone();
// let mut node3 = node3.clone();
// node1.send_cmd_obj(ev.to_repr_tree(&ctx));
// node2.send_cmd_obj(ev.to_repr_tree(&ctx));
// node3.send_cmd_obj(ev.to_repr_tree(&ctx));
} }
}); });
@ -132,22 +142,42 @@ async fn main() {
}) })
.offset(Vector2::new(5, 0)), .offset(Vector2::new(5, 0)),
); );
compositor.write().unwrap().push( edittree_digit.read().unwrap().display_view().offset(Vector2::new(0,2)) );
let label = ctx.read().unwrap().type_term_to_str(&rt_digit.read().unwrap().get_type()); /* let label = ctx.read().unwrap().type_term_to_str(&node1.get_type());
compositor compositor
.write() .write()
.unwrap() .unwrap()
.push(nested_tty::make_label(&label).offset(Vector2::new(0, 1))); .push(nested_tty::make_label(&label).offset(Vector2::new(0, 2)));
compositor.write().unwrap().push( edittree.read().unwrap().display_view().offset(Vector2::new(0,4)) );
let label = ctx.read().unwrap().type_term_to_str(&rt_string.read().unwrap().get_type());
compositor compositor
.write() .write()
.unwrap() .unwrap()
.push(nested_tty::make_label(&label).offset(Vector2::new(0, 3))); .push(node1.display_view().offset(Vector2::new(15, 2)));
*/
/*
let label2 = ctx.read().unwrap().type_term_to_str(&node2.get_type());
compositor
.write()
.unwrap()
.push(nested_tty::make_label(&label2).offset(Vector2::new(0, 3)));
compositor
.write()
.unwrap()
.push(node2.display_view().offset(Vector2::new(15, 3)));
let label3 = ctx.read().unwrap().type_term_to_str(&node3.get_type());
compositor
.write()
.unwrap()
.push(nested_tty::make_label(&label3).offset(Vector2::new(0, 4)));
compositor
.write()
.unwrap()
.push(node3.display_view().offset(Vector2::new(25, 4)));
*/
/* write the changes in the view of `term_port` to the terminal /* write the changes in the view of `term_port` to the terminal
*/ */
app.show().await.expect("output error!"); app.show().await.expect("output error!");

2
lib-nested-core/src/edit_tree/mod.rs
View file

@ -10,6 +10,6 @@ pub use {
cursor::TreeCursor, cursor::TreeCursor,
nav::{TreeNav, TreeNavResult, TreeHeightOp}, nav::{TreeNav, TreeNavResult, TreeHeightOp},
treetype::{TreeType}, treetype::{TreeType},
node::EditTree node::NestedNode
}; };

50
lib-nested-core/src/edit_tree/node.rs
View file

@ -14,7 +14,7 @@ use {
}; };
#[derive(Clone)] #[derive(Clone)]
pub struct EdittreeDisplay { pub struct NestedNodeDisplay {
/// display view /// display view
pub view: Arc<RwLock<ReprTree>>, pub view: Arc<RwLock<ReprTree>>,
@ -26,13 +26,13 @@ pub struct EdittreeDisplay {
} }
#[derive(Clone)] #[derive(Clone)]
pub struct EdittreeControl { pub struct NestedNodeEdit {
/// abstract editor /// abstract editor
pub editor: SingletonBuffer< pub editor: SingletonBuffer<
Option< Arc<dyn Any + Send + Sync> > Option< Arc<dyn Any + Send + Sync> >
>, >,
pub spillbuf: Arc<RwLock< Vec< Arc<RwLock< EditTree >> > >>, pub spillbuf: Arc<RwLock< Vec< Arc<RwLock< NestedNode >> > >>,
/// commander & navigation /// commander & navigation
pub cmd: SingletonBuffer< pub cmd: SingletonBuffer<
@ -51,26 +51,26 @@ pub struct EdittreeControl {
* TODO: rename to EditNode * TODO: rename to EditNode
*/ */
#[derive(Clone)] #[derive(Clone)]
pub struct EditTree { pub struct NestedNode {
/// context /// context
pub ctx: Arc<RwLock<Context>>, pub ctx: Arc<RwLock<Context>>,
/// viewports for terminal display /// viewports for terminal display
pub disp: EdittreeDisplay, pub disp: NestedNodeDisplay,
/// editor & commander objects /// editor & commander objects
pub ctrl: EdittreeControl pub edit: NestedNodeEdit
} }
impl EditTree { impl NestedNode {
pub fn new(ctx: Arc<RwLock<Context>>, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> Self { pub fn new(ctx: Arc<RwLock<Context>>, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> Self {
EditTree { NestedNode {
disp: EdittreeDisplay { disp: NestedNodeDisplay {
view: ReprTree::new_arc(Context::parse(&ctx, "Display")), view: ReprTree::new_arc(Context::parse(&ctx, "Display")),
diag: None, diag: None,
depth, depth,
}, },
ctrl: EdittreeControl { edit: NestedNodeEdit {
editor: SingletonBuffer::new(None), editor: SingletonBuffer::new(None),
spillbuf: Arc::new(RwLock::new(Vec::new())), spillbuf: Arc::new(RwLock::new(Vec::new())),
cmd: SingletonBuffer::new(None), cmd: SingletonBuffer::new(None),
@ -82,17 +82,17 @@ impl EditTree {
} }
pub fn set_editor(mut self, editor: Arc<dyn Any + Send + Sync>) -> Self { pub fn set_editor(mut self, editor: Arc<dyn Any + Send + Sync>) -> Self {
self.ctrl.editor.set(Some(editor)); self.edit.editor.set(Some(editor));
self self
} }
pub fn set_cmd(mut self, cmd: Arc<RwLock<dyn ObjCommander + Send + Sync>>) -> Self { pub fn set_cmd(mut self, cmd: Arc<RwLock<dyn ObjCommander + Send + Sync>>) -> Self {
self.ctrl.cmd.set(Some(cmd)); self.edit.cmd.set(Some(cmd));
self self
} }
pub fn set_nav(mut self, nav: Arc<RwLock<dyn TreeNav + Send + Sync>>) -> Self { pub fn set_nav(mut self, nav: Arc<RwLock<dyn TreeNav + Send + Sync>>) -> Self {
self.ctrl.tree_nav.set(Some(nav)); self.edit.tree_nav.set(Some(nav));
self self
} }
@ -108,7 +108,7 @@ impl EditTree {
} }
pub fn get_edit<T: Send + Sync + 'static>(&self) -> Option<Arc<RwLock<T>>> { pub fn get_edit<T: Send + Sync + 'static>(&self) -> Option<Arc<RwLock<T>>> {
if let Some(edit) = self.ctrl.editor.get() { if let Some(edit) = self.edit.editor.get() {
if let Ok(edit) = edit.downcast::<RwLock<T>>() { if let Ok(edit) = edit.downcast::<RwLock<T>>() {
Some(edit) Some(edit)
} else { } else {
@ -132,9 +132,9 @@ impl TreeType for NestedNode {
} }
*/ */
impl TreeNav for EditTree { impl TreeNav for NestedNode {
fn get_cursor(&self) -> TreeCursor { fn get_cursor(&self) -> TreeCursor {
if let Some(tn) = self.ctrl.tree_nav.get() { if let Some(tn) = self.edit.tree_nav.get() {
tn.read().unwrap().get_cursor() tn.read().unwrap().get_cursor()
} else { } else {
TreeCursor::default() TreeCursor::default()
@ -142,7 +142,7 @@ impl TreeNav for EditTree {
} }
fn get_addr_view(&self) -> OuterViewPort<dyn SequenceView<Item = isize>> { fn get_addr_view(&self) -> OuterViewPort<dyn SequenceView<Item = isize>> {
if let Some(tn) = self.ctrl.tree_nav.get() { if let Some(tn) = self.edit.tree_nav.get() {
tn.read().unwrap().get_addr_view() tn.read().unwrap().get_addr_view()
} else { } else {
OuterViewPort::default() OuterViewPort::default()
@ -150,7 +150,7 @@ impl TreeNav for EditTree {
} }
fn get_mode_view(&self) -> OuterViewPort<dyn SingletonView<Item = ListCursorMode>> { fn get_mode_view(&self) -> OuterViewPort<dyn SingletonView<Item = ListCursorMode>> {
if let Some(tn) = self.ctrl.tree_nav.get() { if let Some(tn) = self.edit.tree_nav.get() {
tn.read().unwrap().get_mode_view() tn.read().unwrap().get_mode_view()
} else { } else {
OuterViewPort::default() OuterViewPort::default()
@ -158,7 +158,7 @@ impl TreeNav for EditTree {
} }
fn get_cursor_warp(&self) -> TreeCursor { fn get_cursor_warp(&self) -> TreeCursor {
if let Some(tn) = self.ctrl.tree_nav.get() { if let Some(tn) = self.edit.tree_nav.get() {
tn.read().unwrap().get_cursor_warp() tn.read().unwrap().get_cursor_warp()
} else { } else {
TreeCursor::default() TreeCursor::default()
@ -166,7 +166,7 @@ impl TreeNav for EditTree {
} }
fn get_height(&self, op: &TreeHeightOp) -> usize { fn get_height(&self, op: &TreeHeightOp) -> usize {
if let Some(tn) = self.ctrl.tree_nav.get() { if let Some(tn) = self.edit.tree_nav.get() {
tn.read().unwrap().get_height( op ) tn.read().unwrap().get_height( op )
} else { } else {
0 0
@ -174,7 +174,7 @@ impl TreeNav for EditTree {
} }
fn goby(&mut self, direction: Vector2<isize>) -> TreeNavResult { fn goby(&mut self, direction: Vector2<isize>) -> TreeNavResult {
if let Some(tn) = self.ctrl.tree_nav.get() { if let Some(tn) = self.edit.tree_nav.get() {
tn.write().unwrap().goby(direction) tn.write().unwrap().goby(direction)
} else { } else {
TreeNavResult::Exit TreeNavResult::Exit
@ -182,7 +182,7 @@ impl TreeNav for EditTree {
} }
fn goto(&mut self, new_cursor: TreeCursor) -> TreeNavResult { fn goto(&mut self, new_cursor: TreeCursor) -> TreeNavResult {
if let Some(tn) = self.ctrl.tree_nav.get() { if let Some(tn) = self.edit.tree_nav.get() {
tn.write().unwrap().goto(new_cursor) tn.write().unwrap().goto(new_cursor)
} else { } else {
TreeNavResult::Exit TreeNavResult::Exit
@ -192,7 +192,7 @@ impl TreeNav for EditTree {
use crate::edit_tree::nav::TreeNavCmd; use crate::edit_tree::nav::TreeNavCmd;
impl ObjCommander for EditTree { impl ObjCommander for NestedNode {
fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult { fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult {
if cmd_obj.read().unwrap().get_type() == &Context::parse(&self.ctx, "TreeNavCmd") { if cmd_obj.read().unwrap().get_type() == &Context::parse(&self.ctx, "TreeNavCmd") {
@ -211,7 +211,7 @@ impl ObjCommander for EditTree {
} else { } else {
TreeNavResult::Exit TreeNavResult::Exit
} }
} else if let Some(cmd) = self.ctrl.cmd.get() { } else if let Some(cmd) = self.edit.cmd.get() {
// todo: filter out tree-nav cmds and send them to tree_nav // todo: filter out tree-nav cmds and send them to tree_nav
cmd.write().unwrap().send_cmd_obj(cmd_obj) cmd.write().unwrap().send_cmd_obj(cmd_obj)
} else { } else {
@ -221,7 +221,7 @@ impl ObjCommander for EditTree {
} }
impl Diagnostics for EditTree { impl Diagnostics for NestedNode {
fn get_msg_port(&self) -> OuterViewPort<dyn SequenceView<Item = Message>> { fn get_msg_port(&self) -> OuterViewPort<dyn SequenceView<Item = Message>> {
self.get_diag() self.get_diag()
} }

55
lib-nested-core/src/editors/char/mod.rs
View file

@ -9,45 +9,21 @@ use {
laddertypes::{TypeTerm}, laddertypes::{TypeTerm},
crate::{ crate::{
repr_tree::{Context, ReprTree}, repr_tree::{Context, ReprTree},
edit_tree::{EditTree, TreeNavResult}, edit_tree::{NestedNode, TreeNavResult},
editors::ObjCommander, editors::ObjCommander,
}, },
std::sync::Arc, std::sync::Arc,
std::sync::RwLock std::sync::RwLock
}; };
pub fn init_ctx( ctx: Arc<RwLock<Context>> ) { pub fn init_ctx( ctx: &mut Context ) {
/*
let morphtype = ctx.add_node_ctor(
crate::repr_tree::MorphismType { "Char",
src_type: Context::parse(&ctx, "Char"), Arc::new(|ctx: Arc<RwLock<Context>>, _ty: TypeTerm, depth: OuterViewPort<dyn SingletonView<Item = usize>>| {
dst_type: Context::parse(&ctx, "Char~EditTree") Some(CharEditor::new_node(ctx, depth))
}; }));
*/
ctx.write().unwrap()
.morphisms
.add_morphism(
morphtype,
{
let ctx = ctx.clone();
move |rt, σ| {
/* Create EditTree object
*/
let mut edittree_char = CharEditor::new_edit_tree(
ctx.clone(),
r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
);
/* Insert EditTree into ReprTree
*/
let mut rt = rt.write().unwrap();
rt.insert_leaf(
vec![ Context::parse(&ctx, "EditTree") ].into_iter(),
SingletonBuffer::new( Arc::new(RwLock::new( edittree_char )) ).get_port().into()
);
}
}
);
} }
pub struct CharEditor { pub struct CharEditor {
@ -95,16 +71,19 @@ impl CharEditor {
self.get_port().get_view().unwrap().get() self.get_port().get_view().unwrap().get()
} }
pub fn new_edit_tree( pub fn new_node(ctx0: Arc<RwLock<Context>>, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> NestedNode {
ctx0: Arc<RwLock<Context>>,
depth: OuterViewPort<dyn SingletonView<Item = usize>>
) -> EditTree {
let data = SingletonBuffer::new('\0'); let data = SingletonBuffer::new('\0');
let ctx = ctx0.clone(); let ctx = ctx0.clone();
let editor = Arc::new(RwLock::new(CharEditor{ ctx, data: data.clone() })); let editor = Arc::new(RwLock::new(CharEditor{ ctx, data: data.clone() }));
EditTree::new( NestedNode::new(
ctx0.clone(), ctx0.clone(),
/*
ReprTree::new_leaf(
ctx0.read().unwrap().type_term_from_str("Char").unwrap(),
data.get_port().into()
),
*/
depth depth
) )
.set_cmd( editor.clone() ) .set_cmd( editor.clone() )

97
lib-nested-core/src/editors/integer/editor.rs
View file

@ -14,7 +14,7 @@ use {
crate::{ crate::{
editors::{list::{ListCmd}, ObjCommander}, editors::{list::{ListCmd}, ObjCommander},
repr_tree::{Context, ReprTree}, repr_tree::{Context, ReprTree},
edit_tree::{EditTree, TreeNav, TreeNavResult, TreeCursor, diagnostics::{Message}}, edit_tree::{NestedNode, TreeNav, TreeNavResult, TreeCursor, diagnostics::{Message}},
}, },
std::sync::Arc, std::sync::Arc,
std::sync::RwLock, std::sync::RwLock,
@ -22,51 +22,6 @@ use {
cgmath::{Point2} cgmath::{Point2}
}; };
pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
// todo: proper scoping of Radix variable
ctx.write().unwrap().add_varname("Radix");
let morphtype =
crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<Digit Radix>"),
dst_type: Context::parse(&ctx, "<Digit Radix>~EditTree")
};
ctx.write().unwrap()
.morphisms
.add_morphism(
morphtype,
{
let ctx = ctx.clone();
move |rt, σ| {
let radix =
match σ.get( &laddertypes::TypeID::Var(ctx.read().unwrap().get_var_typeid("Radix").unwrap()) ) {
Some(TypeTerm::Num(n)) => *n as u32,
_ => 0
};
/* Create EditTree object
*/
let mut edittree_digit = DigitEditor::new(
ctx.clone(),
radix
).into_node(
r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
);
/* Insert EditTree into ReprTree
*/
let mut rt = rt.write().unwrap();
rt.insert_leaf(
vec![ Context::parse(&ctx, "EditTree") ].into_iter(),
SingletonBuffer::new( Arc::new(RwLock::new(edittree_digit)) ).get_port().into()
);
}
}
);
}
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>> //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
pub struct DigitEditor { pub struct DigitEditor {
@ -94,7 +49,9 @@ impl ObjCommander for DigitEditor {
/* in case the character c is not in the range of digit-chars, /* in case the character c is not in the range of digit-chars,
add a message to the diagnostics view add a message to the diagnostics view
*/ */
/* /*
let message = IndexBuffer::from_iter(vec![ let message = IndexBuffer::from_iter(vec![
(Point2::new(1, 0), make_label("invalid digit '")), (Point2::new(1, 0), make_label("invalid digit '")),
(Point2::new(2, 0), make_label(&format!("{}", c)) (Point2::new(2, 0), make_label(&format!("{}", c))
@ -126,39 +83,40 @@ impl DigitEditor {
} }
} }
pub fn into_node(self, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> EditTree { pub fn into_node(self, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> NestedNode {
let data = self.get_data(); let data = self.get_data();
let editor = Arc::new(RwLock::new(self)); let editor = Arc::new(RwLock::new(self));
let ed = editor.write().unwrap(); let ed = editor.write().unwrap();
let r = ed.radix; let r = ed.radix;
EditTree::new(ed.ctx.clone(), depth) NestedNode::new(ed.ctx.clone(), /*data,*/ depth)
.set_editor(editor.clone())
.set_cmd(editor.clone()) .set_cmd(editor.clone())
/*
.set_view(
ed.data
.get_port()
.map(move |c| {
TerminalAtom::new(
c.unwrap_or('?'),
if c.unwrap_or('?').to_digit(r).is_some() {
TerminalStyle::fg_color((90, 160, 90))
} else {
//TerminalStyle::bg_color((90, 10, 10))
TerminalStyle::fg_color((200, 40, 40))
},
)
})
.to_grid()
)
.set_diag( .set_diag(
ed.msg.get_port().to_sequence() ed.msg.get_port().to_sequence()
) )
}
pub fn attach_to(&mut self, source: OuterViewPort<dyn SingletonView<Item = u32>>) {
/*
source.add_observer(
Arc::new(NotifyFnObserver::new(|_msg| {
self.data.set( source.get() )
}))
);
*/ */
} }
pub fn get_data_port(&self) -> OuterViewPort<dyn SingletonView<Item = Result<u32, char>>> { pub fn get_data_port(&self) -> OuterViewPort<dyn SingletonView<Item = Option<u32>>> {
let radix = self.radix; let radix = self.radix;
self.data.get_port().map(move |c| self.data.get_port().map(move |c| c?.to_digit(radix))
if let Some(d) = c.unwrap_or('?').to_digit(radix) {
Ok(d)
} else {
Err(c.unwrap_or('?'))
}
)
} }
pub fn get_type(&self) -> TypeTerm { pub fn get_type(&self) -> TypeTerm {
@ -176,9 +134,10 @@ impl DigitEditor {
} }
} }
pub struct PosIntEditor { pub struct PosIntEditor {
radix: u32, radix: u32,
digits: EditTree, digits: NestedNode,
// todo: endianness // todo: endianness
} }
@ -220,7 +179,7 @@ impl PosIntEditor {
*/ */
PosIntEditor { PosIntEditor {
radix, radix,
digits: EditTree::new( digits: NestedNode::new(
ctx, ctx,
r3vi::buffer::singleton::SingletonBuffer::new(0).get_port() r3vi::buffer::singleton::SingletonBuffer::new(0).get_port()
) )
@ -248,7 +207,7 @@ impl PosIntEditor {
self.digits.goto(TreeCursor::none()); self.digits.goto(TreeCursor::none());
} }
pub fn into_node(self) -> EditTree { pub fn into_node(self) -> NestedNode {
self.digits self.digits
} }

4
lib-nested-core/src/editors/list/cmd.rs
View file

@ -5,7 +5,7 @@ use {
crate::{ crate::{
editors::{list::{ListEditor, ListCursor, ListCursorMode}, ObjCommander}, editors::{list::{ListEditor, ListCursor, ListCursorMode}, ObjCommander},
repr_tree::{Context, ReprTree}, repr_tree::{Context, ReprTree},
edit_tree::{EditTree, TreeNav, TreeNavResult, TreeCursor}, edit_tree::{NestedNode, TreeNav, TreeNavResult, TreeCursor},
}, },
std::sync::{Arc, RwLock} std::sync::{Arc, RwLock}
}; };
@ -35,7 +35,7 @@ impl ObjCommander for ListEditor {
fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult { fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult {
let cmd_repr = cmd_obj.read().unwrap(); let cmd_repr = cmd_obj.read().unwrap();
if let Some(view) = cmd_repr.get_view::<dyn SingletonView<Item = EditTree>>() { if let Some(view) = cmd_repr.get_view::<dyn SingletonView<Item = NestedNode>>() {
let node = view.get(); let node = view.get();
let cur = self.cursor.get(); let cur = self.cursor.get();

54
lib-nested-core/src/editors/list/ctx.rs
View file

@ -1,5 +1,5 @@
use { use {
r3vi::{view::{OuterViewPort, singleton::*}, buffer::singleton::*}, r3vi::{view::{OuterViewPort, singleton::*}},
laddertypes::{TypeTerm}, laddertypes::{TypeTerm},
crate::{ crate::{
repr_tree::{Context}, repr_tree::{Context},
@ -10,37 +10,33 @@ use {
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>> //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
pub fn init_ctx(ctx: Arc<RwLock<Context>>) { pub fn init_ctx(ctx: &mut Context) {
ctx.write().unwrap().add_list_typename("List".into()); ctx.add_typename("ListCmd".into());
ctx.write().unwrap().add_varname("Item"); ctx.add_list_typename("List".into());
let mt = crate::repr_tree::MorphismType { /*
src_type: Context::parse(&ctx, "<List Item>"), ctx.add_node_ctor(
dst_type: Context::parse(&ctx, "<List Item>~EditTree") "List", Arc::new(
}; |ctx: Arc<RwLock<Context>>, ty: TypeTerm, depth: OuterViewPort<dyn SingletonView<Item = usize>>| {
ctx.write().unwrap().morphisms.add_morphism( match ty {
mt, TypeTerm::App(args) => {
{ if args.len() > 1 {
let ctx = ctx.clone(); let typ = args[1].clone();
move |rt, σ| {
let item_id = laddertypes::TypeID::Var( ctx.read().unwrap().get_var_typeid("Item").unwrap() );
if let Some( item_type ) = σ.get( &item_id ) {
let mut edittree_list = ListEditor::new(
ctx.clone(),
item_type.clone()
).into_node(
r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
);
let mut rt = rt.write().unwrap(); let mut node = ListEditor::new(ctx.clone(), typ).into_node(depth);
rt.insert_leaf(
vec![ Context::parse(&ctx, "EditTree") ].into_iter(), // PTYListController::for_node( &mut node, Some(','), Some('}') );
SingletonBuffer::new( Arc::new(RwLock::new( edittree_list )) ).get_port().into() // PTYListStyle::for_node( &mut node, ("{",", ","}") );
);
} else { Some(node)
eprintln!("no item type"); } else {
None
}
}
_ => None
} }
} }
} )
); );
*/
} }

51
lib-nested-core/src/editors/list/editor.rs
View file

@ -6,7 +6,7 @@ use {
laddertypes::{TypeTerm}, laddertypes::{TypeTerm},
crate::{ crate::{
repr_tree::{Context, ReprTree}, repr_tree::{Context, ReprTree},
edit_tree::{EditTree, TreeNav, TreeCursor, diagnostics::Diagnostics}, edit_tree::{NestedNode, TreeNav, TreeCursor, diagnostics::Diagnostics},
editors::{list::{ListCursor, ListCursorMode, ListCmd}, ObjCommander}, editors::{list::{ListCursor, ListCursorMode, ListCmd}, ObjCommander},
}, },
std::sync::{Arc, RwLock} std::sync::{Arc, RwLock}
@ -18,9 +18,9 @@ pub struct ListEditor {
pub cursor: SingletonBuffer<ListCursor>, pub cursor: SingletonBuffer<ListCursor>,
// todo: (?) remove RwLock<..> around NestedNode ?? // todo: (?) remove RwLock<..> around NestedNode ??
pub data: VecBuffer< Arc<RwLock<EditTree>> >, pub data: VecBuffer< Arc<RwLock<NestedNode>> >,
pub spillbuf: Arc<RwLock<Vec<Arc<RwLock<EditTree>>>>>, pub spillbuf: Arc<RwLock<Vec<Arc<RwLock<NestedNode>>>>>,
pub(super) addr_port: OuterViewPort<dyn SequenceView<Item = isize>>, pub(super) addr_port: OuterViewPort<dyn SequenceView<Item = isize>>,
pub(super) mode_port: OuterViewPort<dyn SingletonView<Item = ListCursorMode>>, pub(super) mode_port: OuterViewPort<dyn SingletonView<Item = ListCursorMode>>,
@ -39,7 +39,7 @@ impl ListEditor {
typ: TypeTerm, typ: TypeTerm,
) -> Self { ) -> Self {
let cursor = SingletonBuffer::new(ListCursor::default()); let cursor = SingletonBuffer::new(ListCursor::default());
let data : VecBuffer<Arc<RwLock<EditTree>>> = VecBuffer::new(); let data : VecBuffer<Arc<RwLock<NestedNode>>> = VecBuffer::new();
ListEditor { ListEditor {
mode_port: cursor mode_port: cursor
@ -100,7 +100,7 @@ impl ListEditor {
} }
} }
pub fn into_node(mut self, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> EditTree { pub fn into_node(mut self, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> NestedNode {
let data = self.get_data(); let data = self.get_data();
let ctx = self.ctx.clone(); let ctx = self.ctx.clone();
@ -109,7 +109,7 @@ impl ListEditor {
let e = editor.read().unwrap(); let e = editor.read().unwrap();
let mut node = EditTree::new(ctx, depth) let mut node = NestedNode::new(ctx, depth)
.set_editor(editor.clone()) .set_editor(editor.clone())
.set_nav(editor.clone()) .set_nav(editor.clone())
.set_cmd(editor.clone()) .set_cmd(editor.clone())
@ -131,7 +131,7 @@ impl ListEditor {
.flatten() .flatten()
); );
node.ctrl.spillbuf = e.spillbuf.clone(); node.edit.spillbuf = e.spillbuf.clone();
node node
} }
@ -150,7 +150,7 @@ impl ListEditor {
self.cursor.get_port() self.cursor.get_port()
} }
pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = EditTree>> { pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = NestedNode>> {
self.data.get_port().to_sequence().map( self.data.get_port().to_sequence().map(
|x| x.read().unwrap().clone() |x| x.read().unwrap().clone()
) )
@ -164,7 +164,7 @@ impl ListEditor {
) )
} }
pub fn get_item(&self) -> Option<EditTree> { pub fn get_item(&self) -> Option<NestedNode> {
if let Some(idx) = self.cursor.get().idx { if let Some(idx) = self.cursor.get().idx {
let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize; let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize;
if idx < self.data.len() { if idx < self.data.len() {
@ -175,9 +175,9 @@ impl ListEditor {
} else { } else {
None None
} }
} }
pub fn get_item_mut(&mut self) -> Option<MutableVecAccess<Arc<RwLock<EditTree>>>> { pub fn get_item_mut(&mut self) -> Option<MutableVecAccess<Arc<RwLock<NestedNode>>>> {
if let Some(idx) = self.cursor.get().idx { if let Some(idx) = self.cursor.get().idx {
let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize; let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize;
if idx < self.data.len() { if idx < self.data.len() {
@ -228,7 +228,7 @@ impl ListEditor {
} }
/// insert a new element /// insert a new element
pub fn insert(&mut self, item: Arc<RwLock<EditTree>>) { pub fn insert(&mut self, item: Arc<RwLock<NestedNode>>) {
item.read().unwrap().disp.depth.0.set_view( item.read().unwrap().disp.depth.0.set_view(
self.depth.map(|d| d+1).get_view() self.depth.map(|d| d+1).get_view()
); );
@ -306,15 +306,9 @@ impl ListEditor {
self.set_leaf_mode(ListCursorMode::Insert); self.set_leaf_mode(ListCursorMode::Insert);
self.nexd(); self.nexd();
let mut b = item.ctrl.spillbuf.write().unwrap(); let mut b = item.edit.spillbuf.write().unwrap();
/* TODO
let rt = ReprTree::new_arc(self.typ.clone()); let mut tail_node = Context::make_node(&self.ctx, self.typ.clone(), self.depth.map(|d| d+1)).unwrap();
let new_edittree = self.ctx.read().unwrap()
.setup_edittree(
rt,
self.depth.map(|d| d+1)
);
let mut tail_node = new_edittree.write().unwrap();
tail_node.goto(TreeCursor::home()); tail_node.goto(TreeCursor::home());
for node in b.iter() { for node in b.iter() {
@ -322,7 +316,7 @@ impl ListEditor {
.send_cmd_obj( .send_cmd_obj(
ReprTree::new_leaf( ReprTree::new_leaf(
Context::parse(&self.ctx, "NestedNode"), Context::parse(&self.ctx, "NestedNode"),
SingletonBuffer::<EditTree>::new( SingletonBuffer::<NestedNode>::new(
node.read().unwrap().clone() node.read().unwrap().clone()
).get_port().into() ).get_port().into()
) )
@ -337,12 +331,11 @@ impl ListEditor {
if cur.tree_addr.len() > 1 { if cur.tree_addr.len() > 1 {
tail_node.dn(); tail_node.dn();
} }
drop(tail_node);
self.insert( self.insert(
new_edittree Arc::new(RwLock::new(tail_node))
); );
*/
} else { } else {
self.up(); self.up();
self.listlist_split(); self.listlist_split();
@ -373,12 +366,12 @@ impl ListEditor {
let old_cur = pxv_editor.get_cursor(); let old_cur = pxv_editor.get_cursor();
let data = cur_editor.ctrl.spillbuf.read().unwrap(); let data = cur_editor.edit.spillbuf.read().unwrap();
for x in data.iter() { for x in data.iter() {
pxv_editor.send_cmd_obj( pxv_editor.send_cmd_obj(
ReprTree::new_leaf( ReprTree::new_leaf(
Context::parse(&self.ctx, "NestedNode"), Context::parse(&self.ctx, "NestedNode"),
SingletonBuffer::<EditTree>::new( SingletonBuffer::<NestedNode>::new(
x.read().unwrap().clone() x.read().unwrap().clone()
).get_port().into() ).get_port().into()
) )
@ -431,13 +424,13 @@ impl ListEditor {
leaf_mode: ListCursorMode::Insert leaf_mode: ListCursorMode::Insert
}); });
let data = nxd_editor.ctrl.spillbuf.read().unwrap(); let data = nxd_editor.edit.spillbuf.read().unwrap();
for x in data.iter() { for x in data.iter() {
cur_editor.send_cmd_obj( cur_editor.send_cmd_obj(
ReprTree::new_leaf( ReprTree::new_leaf(
Context::parse(&self.ctx, "NestedNode"), Context::parse(&self.ctx, "NestedNode"),
SingletonBuffer::<EditTree>::new( SingletonBuffer::<NestedNode>::new(
x.read().unwrap().clone() x.read().unwrap().clone()
).get_port().into() ).get_port().into()
) )

8
lib-nested-core/src/editors/list/segment.rs
View file

@ -9,7 +9,7 @@ use {
}, },
crate::{ crate::{
editors::list::{ListCursor, ListCursorMode}, editors::list::{ListCursor, ListCursorMode},
edit_tree::{EditTree} edit_tree::{NestedNode}
}, },
std::sync::Arc, std::sync::Arc,
std::sync::RwLock, std::sync::RwLock,
@ -18,13 +18,13 @@ use {
pub enum ListSegment { pub enum ListSegment {
InsertCursor, InsertCursor,
Item { Item {
editor: EditTree, editor: NestedNode,
cur_dist: isize, cur_dist: isize,
} }
} }
pub struct ListSegmentSequence { pub struct ListSegmentSequence {
data: Arc<dyn SequenceView<Item = EditTree>>, data: Arc<dyn SequenceView<Item = NestedNode>>,
cursor: Arc<dyn SingletonView<Item = ListCursor>>, cursor: Arc<dyn SingletonView<Item = ListCursor>>,
cur_cursor: ListCursor, cur_cursor: ListCursor,
@ -88,7 +88,7 @@ impl SequenceView for ListSegmentSequence {
impl ListSegmentSequence { impl ListSegmentSequence {
pub fn new( pub fn new(
cursor_port: OuterViewPort<dyn SingletonView<Item = ListCursor>>, cursor_port: OuterViewPort<dyn SingletonView<Item = ListCursor>>,
data_port: OuterViewPort<dyn SequenceView<Item = EditTree>>, data_port: OuterViewPort<dyn SequenceView<Item = NestedNode>>,
) -> Arc<RwLock<Self>> { ) -> Arc<RwLock<Self>> {
let out_port = ViewPort::new(); let out_port = ViewPort::new();
let mut proj_helper = ProjectionHelper::new(out_port.update_hooks.clone()); let mut proj_helper = ProjectionHelper::new(out_port.update_hooks.clone());

3
lib-nested-core/src/editors/mod.rs
View file

@ -4,7 +4,7 @@ pub mod list;
//pub mod sum; //pub mod sum;
pub mod char; pub mod char;
pub mod integer; //pub mod integer;
//pub mod typeterm; //pub mod typeterm;
@ -24,4 +24,3 @@ pub trait ObjCommander {
fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult; fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult;
} }

44
lib-nested-core/src/repr_tree/context.rs
View file

@ -3,7 +3,7 @@ use {
laddertypes::{TypeDict, TypeTerm, TypeID}, laddertypes::{TypeDict, TypeTerm, TypeID},
crate::{ crate::{
repr_tree::{ReprTree, MorphismType, GenericReprTreeMorphism, MorphismBase}, repr_tree::{ReprTree, MorphismType, GenericReprTreeMorphism, MorphismBase},
edit_tree::EditTree edit_tree::NestedNode
}, },
std::{ std::{
collections::HashMap, collections::HashMap,
@ -29,16 +29,12 @@ pub struct Context {
pub list_types: Vec< TypeID >, pub list_types: Vec< TypeID >,
pub meta_chars: Vec< char >, pub meta_chars: Vec< char >,
edittree_hook: Arc< dyn Fn(Arc<RwLock<EditTree>>, TypeTerm) + Send +Sync +'static >,
/// recursion /// recursion
parent: Option<Arc<RwLock<Context>>>, parent: Option<Arc<RwLock<Context>>>,
} }
impl Context { impl Context {
pub fn with_parent( pub fn with_parent(parent: Option<Arc<RwLock<Context>>>) -> Self {
parent: Option<Arc<RwLock<Context>>>
) -> Self {
Context { Context {
type_dict: match parent.as_ref() { type_dict: match parent.as_ref() {
Some(p) => p.read().unwrap().type_dict.clone(), Some(p) => p.read().unwrap().type_dict.clone(),
@ -55,8 +51,6 @@ impl Context {
None => Vec::new() None => Vec::new()
}, },
parent, parent,
edittree_hook: Arc::new(|_et, _t| {})
} }
} }
@ -64,10 +58,6 @@ impl Context {
Context::with_parent(None) Context::with_parent(None)
} }
pub fn set_edittree_hook(&mut self, hook: Arc< dyn Fn(Arc<RwLock<EditTree>>, TypeTerm) + Send +Sync +'static >) {
self.edittree_hook = hook;
}
pub fn depth(&self) -> usize { pub fn depth(&self) -> usize {
if let Some(parent) = self.parent.as_ref() { if let Some(parent) = self.parent.as_ref() {
parent.read().unwrap().depth() + 1 parent.read().unwrap().depth() + 1
@ -175,36 +165,6 @@ impl Context {
None None
} }
} }
pub fn setup_edittree(
&self,
rt: Arc<RwLock<ReprTree>>,
depth: OuterViewPort<dyn SingletonView<Item = usize>>
) -> Arc<RwLock<EditTree>> {
let ladder = TypeTerm::Ladder(vec![
rt.read().unwrap().get_type().clone(),
self.type_term_from_str("EditTree").expect("")
]);
self.morphisms.morph(
rt.clone(),
&ladder
);
let new_edittree = rt
.read().unwrap()
.descend(
self.type_term_from_str("EditTree").expect("")
).unwrap()
.read().unwrap()
.get_view::<dyn SingletonView<Item = Arc<RwLock<EditTree>> >>()
.unwrap()
.get();
(*self.edittree_hook)( new_edittree.clone(), rt.read().unwrap().get_type().clone() );
new_edittree
}
} }
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>> //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>

13
lib-nested-core/src/repr_tree/mod.rs
View file

@ -7,7 +7,7 @@ pub use {
}; };
use { use {
r3vi::view::{AnyOuterViewPort, OuterViewPort, View, singleton::*}, r3vi::view::{AnyOuterViewPort, OuterViewPort, View},
laddertypes::{TypeTerm}, laddertypes::{TypeTerm},
std::{ std::{
collections::HashMap, collections::HashMap,
@ -26,10 +26,10 @@ pub struct ReprTree {
impl std::fmt::Debug for ReprTree { impl std::fmt::Debug for ReprTree {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
writeln!(f, "| type: {:?}", self.type_tag)?; write!(f, "type: {:?}", self.type_tag)?;
for (_k,x) in self.branches.iter() { for (_k,x) in self.branches.iter() {
writeln!(f, "|--> child: {:?}", x)?; write!(f, "child: {:?}", x)?;
} }
Ok(()) Ok(())
@ -100,13 +100,6 @@ impl ReprTree {
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>> //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
pub fn view_char(&self) -> OuterViewPort<dyn SingletonView<Item = char>> {
self.get_port::<dyn SingletonView<Item = char>>().expect("no char-view available")
}
pub fn view_u64(&self) -> OuterViewPort<dyn SingletonView<Item = u64>> {
self.get_port::<dyn SingletonView<Item = u64>>().expect("no u64-view available")
}
pub fn get_port<V: View + ?Sized + 'static>(&self) -> Option<OuterViewPort<V>> pub fn get_port<V: View + ?Sized + 'static>(&self) -> Option<OuterViewPort<V>>
where where

4
lib-nested-core/src/repr_tree/morphism.rs
View file

@ -68,6 +68,7 @@ impl MorphismBase {
); );
if let Ok(σ) = unification_problem.solve() { if let Ok(σ) = unification_problem.solve() {
eprintln!("found matching morphism");
return Some((m, σ)); return Some((m, σ));
} }
} }
@ -80,8 +81,7 @@ impl MorphismBase {
repr_tree: Arc<RwLock<ReprTree>>, repr_tree: Arc<RwLock<ReprTree>>,
target_type: &TypeTerm target_type: &TypeTerm
) { ) {
let t = repr_tree.read().unwrap().get_type().clone(); if let Some((m, σ)) = self.find_morphism( repr_tree.read().unwrap().get_type(), target_type ) {
if let Some((m, σ)) = self.find_morphism( &t, target_type ) {
(m.repr_tree_op)( repr_tree.clone(), &σ ); (m.repr_tree_op)( repr_tree.clone(), &σ );
} else { } else {
eprintln!("could not find morphism"); eprintln!("could not find morphism");

9
lib-nested-tty/src/edit_tree/keymap.rs
View file

@ -99,12 +99,11 @@ impl TerminalEvent {
} }
} }
_ => { _ => {
ReprTree::new_leaf( ReprTree::new_leaf(
Context::parse(&ctx, "TerminalEvent"), Context::parse(&ctx, "TerminalEvent"),
SingletonBuffer::new(self.clone()).get_port().into() SingletonBuffer::new(self.clone()).get_port().into()
) )
} }
} }
} }
} }

36
lib-nested-tty/src/editors/list.rs
View file

@ -6,7 +6,7 @@ use {
nested::{ nested::{
repr_tree::{Context, ReprTree}, repr_tree::{Context, ReprTree},
editors::list::*, editors::list::*,
edit_tree::{TreeCursor, TreeNav, TreeNavResult, EditTree}, edit_tree::{TreeCursor, TreeNav, TreeNavResult, NestedNode},
}, },
crate::{ crate::{
DisplaySegment, DisplaySegment,
@ -91,7 +91,7 @@ impl PTYListStyle {
.flatten() .flatten()
} }
pub fn for_node(node: &mut EditTree, style: (&str, &str, &str)) { pub fn for_node(node: &mut NestedNode, style: (&str, &str, &str)) {
node.disp.view node.disp.view
.write().unwrap() .write().unwrap()
.insert_branch(ReprTree::new_leaf( .insert_branch(ReprTree::new_leaf(
@ -135,11 +135,10 @@ impl PTYListController {
} }
pub fn for_node( pub fn for_node(
node: &mut EditTree, node: &mut NestedNode,
split_char: Option<char>, split_char: Option<char>,
close_char: Option<char> close_char: Option<char>
) { ) {
/*
{ {
let ctx = node.ctx.as_ref(); let ctx = node.ctx.as_ref();
let mut ctx = ctx.write().unwrap(); let mut ctx = ctx.write().unwrap();
@ -151,15 +150,15 @@ impl PTYListController {
ctx.meta_chars.push(*c); ctx.meta_chars.push(*c);
} }
} }
*/
let editor = node.get_edit::<ListEditor>().unwrap(); let editor = node.get_edit::<ListEditor>().unwrap();
let controller = Arc::new(RwLock::new(PTYListController::from_editor( editor, split_char, close_char, node.disp.depth.clone() ))); let controller = Arc::new(RwLock::new(PTYListController::from_editor( editor, split_char, close_char, node.disp.depth.clone() )));
node.ctrl.cmd.set(Some(controller.clone())); node.edit.cmd.set(Some(controller.clone()));
node.ctrl.close_char.set(close_char); node.edit.close_char.set(close_char);
} }
pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = EditTree>> { pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = NestedNode>> {
self.editor.read().unwrap().get_data_port() self.editor.read().unwrap().get_data_port()
} }
@ -167,7 +166,7 @@ impl PTYListController {
self.editor.write().unwrap().clear(); self.editor.write().unwrap().clear();
} }
pub fn get_item(&self) -> Option<EditTree> { pub fn get_item(&self) -> Option<NestedNode> {
self.editor.read().unwrap().get_item() self.editor.read().unwrap().get_item()
} }
@ -220,27 +219,26 @@ impl PTYListController {
match cur.mode { match cur.mode {
ListCursorMode::Insert => { ListCursorMode::Insert => {
let rt = ReprTree::new_arc(e.typ.clone()); /* TODO
let new_edittree = ctx.setup_edittree( let mut new_edit = Context::make_node(&e.ctx, e.typ.clone(), self.depth.map(|d| d+1)).unwrap();
rt, new_edit.goto(TreeCursor::home());
self.depth.map(|d| d+1)
); match new_edit.send_cmd_obj(cmd_obj.clone()) {
let mut ne = new_edittree.write().unwrap();
match ne.send_cmd_obj(cmd_obj.clone()) {
TreeNavResult::Continue => { TreeNavResult::Continue => {
drop(ne); e.insert(Arc::new(RwLock::new(new_edit.clone())));
e.insert(new_edittree.clone());
TreeNavResult::Continue TreeNavResult::Continue
} }
TreeNavResult::Exit => { TreeNavResult::Exit => {
TreeNavResult::Exit TreeNavResult::Exit
} }
} }
*/
TreeNavResult::Continue
}, },
ListCursorMode::Select => { ListCursorMode::Select => {
if let Some(item) = e.get_item_mut() { if let Some(item) = e.get_item_mut() {
let res = item.write().unwrap().send_cmd_obj(cmd_obj.clone()); let res = item.write().unwrap().send_cmd_obj(cmd_obj.clone());
let child_close_char = item.read().unwrap().ctrl.close_char.get(); let child_close_char = item.read().unwrap().edit.close_char.get();
match res { match res {
TreeNavResult::Continue => TreeNavResult::Continue, TreeNavResult::Continue => TreeNavResult::Continue,

83
lib-nested-tty/src/editors/mod.rs
View file

@ -3,7 +3,7 @@ pub mod list;
use { use {
nested::{ nested::{
edit_tree::{EditTree}, edit_tree::{NestedNode},
repr_tree::{ReprTree, Context} repr_tree::{ReprTree, Context}
}, },
r3vi::{ r3vi::{
@ -13,22 +13,22 @@ use {
crate::{ crate::{
make_label, make_label,
DisplaySegment, DisplaySegment,
atom::{TerminalAtom, TerminalStyle} atom::TerminalAtom
} }
}; };
/*
pub fn edittree_make_char_view( pub fn node_make_char_view(
node: EditTree node: NestedNode
) -> EditTree { ) -> NestedNode {
node.disp.view node.disp.view
.write().unwrap() .write().unwrap()
.insert_branch(ReprTree::new_leaf( .insert_branch(ReprTree::new_leaf(
Context::parse(&node.ctx, "TerminalView"), Context::parse(&node.ctx, "TerminalView"),
node.get_edit::< nested::editors::char::CharEditor >() node.data
.unwrap()
.read() .read()
.unwrap() .unwrap()
.get_port() .get_port::<dyn SingletonView<Item = char>>()
.expect("unable to get Char-view")
.map(move |c| TerminalAtom::from(if c == '\0' { ' ' } else { c })) .map(move |c| TerminalAtom::from(if c == '\0' { ' ' } else { c }))
.to_grid() .to_grid()
.into(), .into(),
@ -37,46 +37,19 @@ pub fn edittree_make_char_view(
node node
} }
pub fn edittree_make_digit_view( pub fn node_make_seq_view(
node: EditTree mut node: NestedNode
) -> EditTree { ) -> NestedNode {
node.disp.view node.disp.view
.write().unwrap() .write().unwrap()
.insert_branch(ReprTree::new_leaf( .insert_branch(ReprTree::new_leaf(
Context::parse(&node.ctx, "TerminalView"), Context::parse(&node.ctx, "TerminalView"),
node.get_edit::< nested::editors::integer::DigitEditor >() node.data
.unwrap()
.read() .read()
.unwrap() .unwrap()
.get_data_port() .get_port::<dyn SequenceView<Item = NestedNode>>()
.map(move |digit| .expect("unable to get Seq-view")
match digit { .map(move |char_node| node_make_tty_view(char_node.clone()).display_view() )
Ok(digit) => TerminalAtom::new( char::from_digit(digit, 16).unwrap_or('?'), TerminalStyle::fg_color((220, 220, 0)) ),
Err(c) => TerminalAtom::new( c, TerminalStyle::fg_color((220, 0, 0)) )
}
)
.to_grid()
.into(),
));
node
}
/*
pub fn edittree_make_seq_view(
mut node: EditTree
) -> EditTree {
node.disp.view
.write().unwrap()
.insert_branch(ReprTree::new_leaf(
Context::parse(&node.ctx, "TerminalView"),
node.get_edit::< nested::editors::list::ListEditor >()
.unwrap()
.read().unwrap()
.get_data_port()
.map(move |item_edittree|
edittree_make_tty_view( item_edittree ).display_view()
)
.wrap(make_label("("), make_label(")")) .wrap(make_label("("), make_label(")"))
.to_grid_horizontal() .to_grid_horizontal()
.flatten() .flatten()
@ -84,4 +57,28 @@ pub fn edittree_make_seq_view(
)); ));
node node
} }
pub fn node_make_list_edit(
mut node: NestedNode
) -> NestedNode {
list::PTYListStyle::for_node( &mut node, ("(", "", ")") );
list::PTYListController::for_node( &mut node, None, None );
node
}
pub fn node_make_tty_view(
node: NestedNode
) -> NestedNode {
if node.data.read().unwrap().get_type() == &Context::parse(&node.ctx, "Char") {
node_make_char_view( node )
} else if node.data.read().unwrap().get_type() == &Context::parse(&node.ctx, "<Seq Char>") {
node_make_seq_view( node )
} else if node.data.read().unwrap().get_type() == &Context::parse(&node.ctx, "<List Char>") {
node_make_list_edit( node )
} else {
eprintln!("couldnt add view");
node
}
}
*/ */

6
lib-nested-tty/src/lib.rs
View file

@ -42,7 +42,7 @@ pub trait DisplaySegment {
use nested::repr_tree::Context; use nested::repr_tree::Context;
use std::sync::{Arc, RwLock}; use std::sync::{Arc, RwLock};
impl DisplaySegment for nested::edit_tree::EditTree { impl DisplaySegment for nested::edit_tree::NestedNode {
fn display_view(&self) -> OuterViewPort<dyn TerminalView> { fn display_view(&self) -> OuterViewPort<dyn TerminalView> {
if let Some( tv_repr ) = self.disp.view if let Some( tv_repr ) = self.disp.view
.read().unwrap() .read().unwrap()
@ -56,10 +56,10 @@ impl DisplaySegment for nested::edit_tree::EditTree {
} }
else { else {
make_label("# could not get ViewPort #") make_label("?")
} }
} else { } else {
make_label("# No TTY View available #") make_label("?")
.map_item(|_p,a| a.add_style_back(TerminalStyle::fg_color((220, 30, 30)))) .map_item(|_p,a| a.add_style_back(TerminalStyle::fg_color((220, 30, 30))))
} }
} }

2
lib-nested-tty/src/tty_application.rs
View file

@ -1,7 +1,7 @@
use { use {
cgmath::Vector2, cgmath::Vector2,
nested::{ nested::{
edit_tree::EditTree, edit_tree::NestedNode,
repr_tree::{Context, ReprTree}, repr_tree::{Context, ReprTree},
}, },
crate::{ crate::{

5
pty-server/Cargo.toml
View file

@ -1,12 +1,11 @@
[package] [package]
authors = ["Michael Sippel <micha@fragmental.art>"] authors = ["Michael Sippel <micha@fragmental.art>"]
name = "pty-server" name = "ansi_parser"
version = "0.1.0" version = "0.1.0"
edition = "2018" edition = "2018"
[dependencies] [dependencies]
nested = { path = "../lib-nested-core" } nested = { path = "../../nested" }
nested-tty = { path = "../lib-nested-tty" }
cgmath = { version = "0.18.0", features = ["serde"] } cgmath = { version = "0.18.0", features = ["serde"] }
serde = { version = "1.0", features = ["serde_derive"] } serde = { version = "1.0", features = ["serde_derive"] }
bincode = "1.3.3" bincode = "1.3.3"