Compare commits
No commits in common. "73d457ba24f3008836ce2ab6886ab5b9162720d4" and "97a5b580dfd7454d87e8c699cf5c6033fa259b27" have entirely different histories.
73d457ba24
...
97a5b580df
21 changed files with 319 additions and 419 deletions
|
|
@ -1,12 +1,11 @@
|
|||
[package]
|
||||
authors = ["Michael Sippel <micha@fragmental.art>"]
|
||||
name = "display-server-tty"
|
||||
name = "display_server"
|
||||
version = "0.1.0"
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
nested = { path = "../lib-nested-core" }
|
||||
nested-tty = { path = "../lib-nested-tty" }
|
||||
nested = { path = "../../nested" }
|
||||
termion = "1.5.5"
|
||||
cgmath = { version = "0.18.0", features = ["serde"] }
|
||||
serde = { version = "1.0", features = ["serde_derive"] }
|
||||
|
|
|
|||
|
|
@ -6,7 +6,6 @@ edition = "2021"
|
|||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
laddertypes = { path = "../../../lib-laddertypes" }
|
||||
r3vi = { path = "../../../lib-r3vi" }
|
||||
nested = { path = "../../lib-nested-core" }
|
||||
nested-tty = { path = "../../lib-nested-tty" }
|
||||
|
|
|
|||
|
|
@ -9,12 +9,11 @@ use {
|
|||
nested::{
|
||||
editors::ObjCommander,
|
||||
repr_tree::{Context, ReprTree},
|
||||
edit_tree::{EditTree}
|
||||
edit_tree::{NestedNode}
|
||||
},
|
||||
nested_tty::{
|
||||
DisplaySegment, TTYApplication,
|
||||
TerminalCompositor, TerminalStyle, TerminalView,
|
||||
TerminalAtom
|
||||
},
|
||||
r3vi::{
|
||||
buffer::{singleton::*, vec::*},
|
||||
|
|
@ -22,101 +21,112 @@ use {
|
|||
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 fn main() {
|
||||
/* setup context & create Editor-Tree
|
||||
*/
|
||||
let ctx = Arc::new(RwLock::new(Context::new()));
|
||||
|
||||
nested::editors::char::init_ctx( ctx.clone() );
|
||||
nested::editors::integer::editor::init_ctx( ctx.clone() );
|
||||
nested::editors::list::init_ctx( ctx.clone() );
|
||||
/* Create a Char-Node with editor & view
|
||||
*/
|
||||
|
||||
let char_type = Context::parse(&ctx, "Char");
|
||||
let digit_type = Context::parse(&ctx, "<Digit Radix>");
|
||||
let list_type = Context::parse(&ctx, "<List Item>");
|
||||
let posint_type = Context::parse(&ctx, "<PosInt Radix>");
|
||||
let item_tyid = ctx.read().unwrap().get_var_typeid("Item").unwrap();
|
||||
|
||||
ctx.write().unwrap().meta_chars.push(',');
|
||||
ctx.write().unwrap().meta_chars.push('\"');
|
||||
ctx.write().unwrap().set_edittree_hook(
|
||||
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());
|
||||
}
|
||||
}
|
||||
let mut char_obj = ReprTree::make_leaf(
|
||||
Context::parse(&ctx, "Char"),
|
||||
SingletonBuffer::new('X').get_port().into()
|
||||
);
|
||||
/*
|
||||
char_obj.insert_branch(
|
||||
Context::parse(&ctx, "EditTree"),
|
||||
SingletonBuffer::new(
|
||||
NestedNode::new()
|
||||
)
|
||||
);
|
||||
|
||||
/* structure of Repr-Tree
|
||||
*
|
||||
* === Repr-Tree ===
|
||||
*
|
||||
* <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
|
||||
* <Digit 16> ~ Char
|
||||
*/
|
||||
rt_digit.write().unwrap()
|
||||
.insert_leaf(
|
||||
vec![ Context::parse(&ctx, "Char") ].into_iter(),
|
||||
SingletonBuffer::new('x').get_port().into()
|
||||
let mut vec_obj = ReprTree::make_leaf(
|
||||
Context::parse(&ctx, "<Vec Char>"),
|
||||
VecBuffer::new(vec!['a', 'b', 'c']).get_port().into()
|
||||
);
|
||||
|
||||
/* setup TTY-Display for DigitEditor
|
||||
let mut char_edit = Context::new_edit_tree(
|
||||
&ctx,
|
||||
// node type
|
||||
Context::parse(&ctx, "Char"),
|
||||
// depth
|
||||
SingletonBuffer::new(0).get_port(),
|
||||
)
|
||||
.unwrap();
|
||||
*/
|
||||
let edittree_digit = ctx.read().unwrap().setup_edittree(rt_digit.clone(), r3vi::buffer::singleton::SingletonBuffer::new(0).get_port());
|
||||
// add a display view to the node
|
||||
//node1 = nested_tty::editors::node_make_tty_view(node1);
|
||||
|
||||
//---
|
||||
let rt_string = ReprTree::new_arc( Context::parse(&ctx, "<List <List Char>>") );
|
||||
let edittree = ctx.read().unwrap().setup_edittree(rt_string.clone(), r3vi::buffer::singleton::SingletonBuffer::new(0).get_port());
|
||||
/* Create a <List Char>-Node with editor & view
|
||||
*/
|
||||
|
||||
/*
|
||||
let mut node2 = Context::make_node(
|
||||
&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
|
||||
*/
|
||||
let app = TTYApplication::new({
|
||||
/* event handler
|
||||
*/
|
||||
|
||||
let ctx = ctx.clone();
|
||||
let et1 = edittree.clone();
|
||||
// let node1 = node1.clone();
|
||||
// let node2 = node2.clone();
|
||||
// let node3 = node3.clone();
|
||||
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)),
|
||||
);
|
||||
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
|
||||
.write()
|
||||
.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
|
||||
.write()
|
||||
.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
|
||||
*/
|
||||
app.show().await.expect("output error!");
|
||||
|
|
|
|||
|
|
@ -10,6 +10,6 @@ pub use {
|
|||
cursor::TreeCursor,
|
||||
nav::{TreeNav, TreeNavResult, TreeHeightOp},
|
||||
treetype::{TreeType},
|
||||
node::EditTree
|
||||
node::NestedNode
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ use {
|
|||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct EdittreeDisplay {
|
||||
pub struct NestedNodeDisplay {
|
||||
/// display view
|
||||
pub view: Arc<RwLock<ReprTree>>,
|
||||
|
||||
|
|
@ -26,13 +26,13 @@ pub struct EdittreeDisplay {
|
|||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct EdittreeControl {
|
||||
pub struct NestedNodeEdit {
|
||||
/// abstract editor
|
||||
pub editor: SingletonBuffer<
|
||||
Option< Arc<dyn Any + Send + Sync> >
|
||||
>,
|
||||
|
||||
pub spillbuf: Arc<RwLock< Vec< Arc<RwLock< EditTree >> > >>,
|
||||
pub spillbuf: Arc<RwLock< Vec< Arc<RwLock< NestedNode >> > >>,
|
||||
|
||||
/// commander & navigation
|
||||
pub cmd: SingletonBuffer<
|
||||
|
|
@ -51,26 +51,26 @@ pub struct EdittreeControl {
|
|||
* TODO: rename to EditNode
|
||||
*/
|
||||
#[derive(Clone)]
|
||||
pub struct EditTree {
|
||||
pub struct NestedNode {
|
||||
/// context
|
||||
pub ctx: Arc<RwLock<Context>>,
|
||||
|
||||
/// viewports for terminal display
|
||||
pub disp: EdittreeDisplay,
|
||||
pub disp: NestedNodeDisplay,
|
||||
|
||||
/// 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 {
|
||||
EditTree {
|
||||
disp: EdittreeDisplay {
|
||||
NestedNode {
|
||||
disp: NestedNodeDisplay {
|
||||
view: ReprTree::new_arc(Context::parse(&ctx, "Display")),
|
||||
diag: None,
|
||||
depth,
|
||||
},
|
||||
ctrl: EdittreeControl {
|
||||
edit: NestedNodeEdit {
|
||||
editor: SingletonBuffer::new(None),
|
||||
spillbuf: Arc::new(RwLock::new(Vec::new())),
|
||||
cmd: SingletonBuffer::new(None),
|
||||
|
|
@ -82,17 +82,17 @@ impl EditTree {
|
|||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
|
|
@ -108,7 +108,7 @@ impl EditTree {
|
|||
}
|
||||
|
||||
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>>() {
|
||||
Some(edit)
|
||||
} else {
|
||||
|
|
@ -132,9 +132,9 @@ impl TreeType for NestedNode {
|
|||
}
|
||||
*/
|
||||
|
||||
impl TreeNav for EditTree {
|
||||
impl TreeNav for NestedNode {
|
||||
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()
|
||||
} else {
|
||||
TreeCursor::default()
|
||||
|
|
@ -142,7 +142,7 @@ impl TreeNav for EditTree {
|
|||
}
|
||||
|
||||
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()
|
||||
} else {
|
||||
OuterViewPort::default()
|
||||
|
|
@ -150,7 +150,7 @@ impl TreeNav for EditTree {
|
|||
}
|
||||
|
||||
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()
|
||||
} else {
|
||||
OuterViewPort::default()
|
||||
|
|
@ -158,7 +158,7 @@ impl TreeNav for EditTree {
|
|||
}
|
||||
|
||||
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()
|
||||
} else {
|
||||
TreeCursor::default()
|
||||
|
|
@ -166,7 +166,7 @@ impl TreeNav for EditTree {
|
|||
}
|
||||
|
||||
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 )
|
||||
} else {
|
||||
0
|
||||
|
|
@ -174,7 +174,7 @@ impl TreeNav for EditTree {
|
|||
}
|
||||
|
||||
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)
|
||||
} else {
|
||||
TreeNavResult::Exit
|
||||
|
|
@ -182,7 +182,7 @@ impl TreeNav for EditTree {
|
|||
}
|
||||
|
||||
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)
|
||||
} else {
|
||||
TreeNavResult::Exit
|
||||
|
|
@ -192,7 +192,7 @@ impl TreeNav for EditTree {
|
|||
|
||||
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 {
|
||||
|
||||
if cmd_obj.read().unwrap().get_type() == &Context::parse(&self.ctx, "TreeNavCmd") {
|
||||
|
|
@ -211,7 +211,7 @@ impl ObjCommander for EditTree {
|
|||
} else {
|
||||
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
|
||||
cmd.write().unwrap().send_cmd_obj(cmd_obj)
|
||||
} 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>> {
|
||||
self.get_diag()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,45 +9,21 @@ use {
|
|||
laddertypes::{TypeTerm},
|
||||
crate::{
|
||||
repr_tree::{Context, ReprTree},
|
||||
edit_tree::{EditTree, TreeNavResult},
|
||||
edit_tree::{NestedNode, TreeNavResult},
|
||||
editors::ObjCommander,
|
||||
},
|
||||
std::sync::Arc,
|
||||
std::sync::RwLock
|
||||
};
|
||||
|
||||
pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
|
||||
|
||||
let morphtype =
|
||||
crate::repr_tree::MorphismType {
|
||||
src_type: Context::parse(&ctx, "Char"),
|
||||
dst_type: Context::parse(&ctx, "Char~EditTree")
|
||||
};
|
||||
|
||||
ctx.write().unwrap()
|
||||
.morphisms
|
||||
.add_morphism(
|
||||
morphtype,
|
||||
{
|
||||
let ctx = ctx.clone();
|
||||
move |rt, σ| {
|
||||
/* Create EditTree object
|
||||
pub fn init_ctx( ctx: &mut Context ) {
|
||||
/*
|
||||
ctx.add_node_ctor(
|
||||
"Char",
|
||||
Arc::new(|ctx: Arc<RwLock<Context>>, _ty: TypeTerm, depth: OuterViewPort<dyn SingletonView<Item = usize>>| {
|
||||
Some(CharEditor::new_node(ctx, depth))
|
||||
}));
|
||||
*/
|
||||
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 {
|
||||
|
|
@ -95,16 +71,19 @@ impl CharEditor {
|
|||
self.get_port().get_view().unwrap().get()
|
||||
}
|
||||
|
||||
pub fn new_edit_tree(
|
||||
ctx0: Arc<RwLock<Context>>,
|
||||
depth: OuterViewPort<dyn SingletonView<Item = usize>>
|
||||
) -> EditTree {
|
||||
pub fn new_node(ctx0: Arc<RwLock<Context>>, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> NestedNode {
|
||||
let data = SingletonBuffer::new('\0');
|
||||
let ctx = ctx0.clone();
|
||||
let editor = Arc::new(RwLock::new(CharEditor{ ctx, data: data.clone() }));
|
||||
|
||||
EditTree::new(
|
||||
NestedNode::new(
|
||||
ctx0.clone(),
|
||||
/*
|
||||
ReprTree::new_leaf(
|
||||
ctx0.read().unwrap().type_term_from_str("Char").unwrap(),
|
||||
data.get_port().into()
|
||||
),
|
||||
*/
|
||||
depth
|
||||
)
|
||||
.set_cmd( editor.clone() )
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ use {
|
|||
crate::{
|
||||
editors::{list::{ListCmd}, ObjCommander},
|
||||
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::RwLock,
|
||||
|
|
@ -22,51 +22,6 @@ use {
|
|||
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 {
|
||||
|
|
@ -94,7 +49,9 @@ impl ObjCommander for DigitEditor {
|
|||
/* in case the character c is not in the range of digit-chars,
|
||||
add a message to the diagnostics view
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
let message = IndexBuffer::from_iter(vec![
|
||||
(Point2::new(1, 0), make_label("invalid digit '")),
|
||||
(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 editor = Arc::new(RwLock::new(self));
|
||||
let ed = editor.write().unwrap();
|
||||
let r = ed.radix;
|
||||
|
||||
EditTree::new(ed.ctx.clone(), depth)
|
||||
.set_editor(editor.clone())
|
||||
NestedNode::new(ed.ctx.clone(), /*data,*/ depth)
|
||||
.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(
|
||||
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;
|
||||
self.data.get_port().map(move |c|
|
||||
if let Some(d) = c.unwrap_or('?').to_digit(radix) {
|
||||
Ok(d)
|
||||
} else {
|
||||
Err(c.unwrap_or('?'))
|
||||
}
|
||||
)
|
||||
self.data.get_port().map(move |c| c?.to_digit(radix))
|
||||
}
|
||||
|
||||
pub fn get_type(&self) -> TypeTerm {
|
||||
|
|
@ -176,9 +134,10 @@ impl DigitEditor {
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
pub struct PosIntEditor {
|
||||
radix: u32,
|
||||
digits: EditTree,
|
||||
digits: NestedNode,
|
||||
|
||||
// todo: endianness
|
||||
}
|
||||
|
|
@ -220,7 +179,7 @@ impl PosIntEditor {
|
|||
*/
|
||||
PosIntEditor {
|
||||
radix,
|
||||
digits: EditTree::new(
|
||||
digits: NestedNode::new(
|
||||
ctx,
|
||||
r3vi::buffer::singleton::SingletonBuffer::new(0).get_port()
|
||||
)
|
||||
|
|
@ -248,7 +207,7 @@ impl PosIntEditor {
|
|||
self.digits.goto(TreeCursor::none());
|
||||
}
|
||||
|
||||
pub fn into_node(self) -> EditTree {
|
||||
pub fn into_node(self) -> NestedNode {
|
||||
self.digits
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ use {
|
|||
crate::{
|
||||
editors::{list::{ListEditor, ListCursor, ListCursorMode}, ObjCommander},
|
||||
repr_tree::{Context, ReprTree},
|
||||
edit_tree::{EditTree, TreeNav, TreeNavResult, TreeCursor},
|
||||
edit_tree::{NestedNode, TreeNav, TreeNavResult, TreeCursor},
|
||||
},
|
||||
std::sync::{Arc, RwLock}
|
||||
};
|
||||
|
|
@ -35,7 +35,7 @@ impl ObjCommander for ListEditor {
|
|||
fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult {
|
||||
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 cur = self.cursor.get();
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
use {
|
||||
r3vi::{view::{OuterViewPort, singleton::*}, buffer::singleton::*},
|
||||
r3vi::{view::{OuterViewPort, singleton::*}},
|
||||
laddertypes::{TypeTerm},
|
||||
crate::{
|
||||
repr_tree::{Context},
|
||||
|
|
@ -10,37 +10,33 @@ use {
|
|||
|
||||
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
|
||||
|
||||
pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
|
||||
ctx.write().unwrap().add_list_typename("List".into());
|
||||
ctx.write().unwrap().add_varname("Item");
|
||||
let mt = crate::repr_tree::MorphismType {
|
||||
src_type: Context::parse(&ctx, "<List Item>"),
|
||||
dst_type: Context::parse(&ctx, "<List Item>~EditTree")
|
||||
};
|
||||
ctx.write().unwrap().morphisms.add_morphism(
|
||||
mt,
|
||||
{
|
||||
let ctx = ctx.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()
|
||||
);
|
||||
pub fn init_ctx(ctx: &mut Context) {
|
||||
ctx.add_typename("ListCmd".into());
|
||||
ctx.add_list_typename("List".into());
|
||||
/*
|
||||
ctx.add_node_ctor(
|
||||
"List", Arc::new(
|
||||
|ctx: Arc<RwLock<Context>>, ty: TypeTerm, depth: OuterViewPort<dyn SingletonView<Item = usize>>| {
|
||||
match ty {
|
||||
TypeTerm::App(args) => {
|
||||
if args.len() > 1 {
|
||||
let typ = args[1].clone();
|
||||
|
||||
let mut rt = rt.write().unwrap();
|
||||
rt.insert_leaf(
|
||||
vec![ Context::parse(&ctx, "EditTree") ].into_iter(),
|
||||
SingletonBuffer::new( Arc::new(RwLock::new( edittree_list )) ).get_port().into()
|
||||
);
|
||||
let mut node = ListEditor::new(ctx.clone(), typ).into_node(depth);
|
||||
|
||||
// PTYListController::for_node( &mut node, Some(','), Some('}') );
|
||||
// PTYListStyle::for_node( &mut node, ("{",", ","}") );
|
||||
|
||||
Some(node)
|
||||
} else {
|
||||
eprintln!("no item type");
|
||||
None
|
||||
}
|
||||
}
|
||||
_ => None
|
||||
}
|
||||
}
|
||||
)
|
||||
);
|
||||
*/
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ use {
|
|||
laddertypes::{TypeTerm},
|
||||
crate::{
|
||||
repr_tree::{Context, ReprTree},
|
||||
edit_tree::{EditTree, TreeNav, TreeCursor, diagnostics::Diagnostics},
|
||||
edit_tree::{NestedNode, TreeNav, TreeCursor, diagnostics::Diagnostics},
|
||||
editors::{list::{ListCursor, ListCursorMode, ListCmd}, ObjCommander},
|
||||
},
|
||||
std::sync::{Arc, RwLock}
|
||||
|
|
@ -18,9 +18,9 @@ pub struct ListEditor {
|
|||
pub cursor: SingletonBuffer<ListCursor>,
|
||||
|
||||
// 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) mode_port: OuterViewPort<dyn SingletonView<Item = ListCursorMode>>,
|
||||
|
|
@ -39,7 +39,7 @@ impl ListEditor {
|
|||
typ: TypeTerm,
|
||||
) -> Self {
|
||||
let cursor = SingletonBuffer::new(ListCursor::default());
|
||||
let data : VecBuffer<Arc<RwLock<EditTree>>> = VecBuffer::new();
|
||||
let data : VecBuffer<Arc<RwLock<NestedNode>>> = VecBuffer::new();
|
||||
|
||||
ListEditor {
|
||||
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 ctx = self.ctx.clone();
|
||||
|
||||
|
|
@ -109,7 +109,7 @@ impl ListEditor {
|
|||
|
||||
let e = editor.read().unwrap();
|
||||
|
||||
let mut node = EditTree::new(ctx, depth)
|
||||
let mut node = NestedNode::new(ctx, depth)
|
||||
.set_editor(editor.clone())
|
||||
.set_nav(editor.clone())
|
||||
.set_cmd(editor.clone())
|
||||
|
|
@ -131,7 +131,7 @@ impl ListEditor {
|
|||
.flatten()
|
||||
);
|
||||
|
||||
node.ctrl.spillbuf = e.spillbuf.clone();
|
||||
node.edit.spillbuf = e.spillbuf.clone();
|
||||
node
|
||||
}
|
||||
|
||||
|
|
@ -150,7 +150,7 @@ impl ListEditor {
|
|||
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(
|
||||
|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 {
|
||||
let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize;
|
||||
if idx < self.data.len() {
|
||||
|
|
@ -177,7 +177,7 @@ impl ListEditor {
|
|||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize;
|
||||
if idx < self.data.len() {
|
||||
|
|
@ -228,7 +228,7 @@ impl ListEditor {
|
|||
}
|
||||
|
||||
/// 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(
|
||||
self.depth.map(|d| d+1).get_view()
|
||||
);
|
||||
|
|
@ -306,15 +306,9 @@ impl ListEditor {
|
|||
self.set_leaf_mode(ListCursorMode::Insert);
|
||||
self.nexd();
|
||||
|
||||
let mut b = item.ctrl.spillbuf.write().unwrap();
|
||||
|
||||
let rt = ReprTree::new_arc(self.typ.clone());
|
||||
let new_edittree = self.ctx.read().unwrap()
|
||||
.setup_edittree(
|
||||
rt,
|
||||
self.depth.map(|d| d+1)
|
||||
);
|
||||
let mut tail_node = new_edittree.write().unwrap();
|
||||
let mut b = item.edit.spillbuf.write().unwrap();
|
||||
/* TODO
|
||||
let mut tail_node = Context::make_node(&self.ctx, self.typ.clone(), self.depth.map(|d| d+1)).unwrap();
|
||||
tail_node.goto(TreeCursor::home());
|
||||
|
||||
for node in b.iter() {
|
||||
|
|
@ -322,7 +316,7 @@ impl ListEditor {
|
|||
.send_cmd_obj(
|
||||
ReprTree::new_leaf(
|
||||
Context::parse(&self.ctx, "NestedNode"),
|
||||
SingletonBuffer::<EditTree>::new(
|
||||
SingletonBuffer::<NestedNode>::new(
|
||||
node.read().unwrap().clone()
|
||||
).get_port().into()
|
||||
)
|
||||
|
|
@ -337,12 +331,11 @@ impl ListEditor {
|
|||
if cur.tree_addr.len() > 1 {
|
||||
tail_node.dn();
|
||||
}
|
||||
drop(tail_node);
|
||||
|
||||
self.insert(
|
||||
new_edittree
|
||||
Arc::new(RwLock::new(tail_node))
|
||||
);
|
||||
|
||||
*/
|
||||
} else {
|
||||
self.up();
|
||||
self.listlist_split();
|
||||
|
|
@ -373,12 +366,12 @@ impl ListEditor {
|
|||
|
||||
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() {
|
||||
pxv_editor.send_cmd_obj(
|
||||
ReprTree::new_leaf(
|
||||
Context::parse(&self.ctx, "NestedNode"),
|
||||
SingletonBuffer::<EditTree>::new(
|
||||
SingletonBuffer::<NestedNode>::new(
|
||||
x.read().unwrap().clone()
|
||||
).get_port().into()
|
||||
)
|
||||
|
|
@ -431,13 +424,13 @@ impl ListEditor {
|
|||
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() {
|
||||
cur_editor.send_cmd_obj(
|
||||
ReprTree::new_leaf(
|
||||
Context::parse(&self.ctx, "NestedNode"),
|
||||
SingletonBuffer::<EditTree>::new(
|
||||
SingletonBuffer::<NestedNode>::new(
|
||||
x.read().unwrap().clone()
|
||||
).get_port().into()
|
||||
)
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ use {
|
|||
},
|
||||
crate::{
|
||||
editors::list::{ListCursor, ListCursorMode},
|
||||
edit_tree::{EditTree}
|
||||
edit_tree::{NestedNode}
|
||||
},
|
||||
std::sync::Arc,
|
||||
std::sync::RwLock,
|
||||
|
|
@ -18,13 +18,13 @@ use {
|
|||
pub enum ListSegment {
|
||||
InsertCursor,
|
||||
Item {
|
||||
editor: EditTree,
|
||||
editor: NestedNode,
|
||||
cur_dist: isize,
|
||||
}
|
||||
}
|
||||
|
||||
pub struct ListSegmentSequence {
|
||||
data: Arc<dyn SequenceView<Item = EditTree>>,
|
||||
data: Arc<dyn SequenceView<Item = NestedNode>>,
|
||||
cursor: Arc<dyn SingletonView<Item = ListCursor>>,
|
||||
|
||||
cur_cursor: ListCursor,
|
||||
|
|
@ -88,7 +88,7 @@ impl SequenceView for ListSegmentSequence {
|
|||
impl ListSegmentSequence {
|
||||
pub fn new(
|
||||
cursor_port: OuterViewPort<dyn SingletonView<Item = ListCursor>>,
|
||||
data_port: OuterViewPort<dyn SequenceView<Item = EditTree>>,
|
||||
data_port: OuterViewPort<dyn SequenceView<Item = NestedNode>>,
|
||||
) -> Arc<RwLock<Self>> {
|
||||
let out_port = ViewPort::new();
|
||||
let mut proj_helper = ProjectionHelper::new(out_port.update_hooks.clone());
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ pub mod list;
|
|||
//pub mod sum;
|
||||
|
||||
pub mod char;
|
||||
pub mod integer;
|
||||
//pub mod integer;
|
||||
//pub mod typeterm;
|
||||
|
||||
|
||||
|
|
@ -24,4 +24,3 @@ pub trait ObjCommander {
|
|||
fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ use {
|
|||
laddertypes::{TypeDict, TypeTerm, TypeID},
|
||||
crate::{
|
||||
repr_tree::{ReprTree, MorphismType, GenericReprTreeMorphism, MorphismBase},
|
||||
edit_tree::EditTree
|
||||
edit_tree::NestedNode
|
||||
},
|
||||
std::{
|
||||
collections::HashMap,
|
||||
|
|
@ -29,16 +29,12 @@ pub struct Context {
|
|||
pub list_types: Vec< TypeID >,
|
||||
pub meta_chars: Vec< char >,
|
||||
|
||||
edittree_hook: Arc< dyn Fn(Arc<RwLock<EditTree>>, TypeTerm) + Send +Sync +'static >,
|
||||
|
||||
/// recursion
|
||||
parent: Option<Arc<RwLock<Context>>>,
|
||||
}
|
||||
|
||||
impl Context {
|
||||
pub fn with_parent(
|
||||
parent: Option<Arc<RwLock<Context>>>
|
||||
) -> Self {
|
||||
pub fn with_parent(parent: Option<Arc<RwLock<Context>>>) -> Self {
|
||||
Context {
|
||||
type_dict: match parent.as_ref() {
|
||||
Some(p) => p.read().unwrap().type_dict.clone(),
|
||||
|
|
@ -55,8 +51,6 @@ impl Context {
|
|||
None => Vec::new()
|
||||
},
|
||||
parent,
|
||||
|
||||
edittree_hook: Arc::new(|_et, _t| {})
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -64,10 +58,6 @@ impl Context {
|
|||
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 {
|
||||
if let Some(parent) = self.parent.as_ref() {
|
||||
parent.read().unwrap().depth() + 1
|
||||
|
|
@ -175,36 +165,6 @@ impl Context {
|
|||
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
|
||||
}
|
||||
}
|
||||
|
||||
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ pub use {
|
|||
};
|
||||
|
||||
use {
|
||||
r3vi::view::{AnyOuterViewPort, OuterViewPort, View, singleton::*},
|
||||
r3vi::view::{AnyOuterViewPort, OuterViewPort, View},
|
||||
laddertypes::{TypeTerm},
|
||||
std::{
|
||||
collections::HashMap,
|
||||
|
|
@ -26,10 +26,10 @@ pub struct ReprTree {
|
|||
|
||||
impl std::fmt::Debug for ReprTree {
|
||||
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() {
|
||||
writeln!(f, "|--> child: {:?}", x)?;
|
||||
write!(f, "child: {:?}", x)?;
|
||||
}
|
||||
|
||||
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>>
|
||||
where
|
||||
|
|
|
|||
|
|
@ -68,6 +68,7 @@ impl MorphismBase {
|
|||
);
|
||||
|
||||
if let Ok(σ) = unification_problem.solve() {
|
||||
eprintln!("found matching morphism");
|
||||
return Some((m, σ));
|
||||
}
|
||||
}
|
||||
|
|
@ -80,8 +81,7 @@ impl MorphismBase {
|
|||
repr_tree: Arc<RwLock<ReprTree>>,
|
||||
target_type: &TypeTerm
|
||||
) {
|
||||
let t = repr_tree.read().unwrap().get_type().clone();
|
||||
if let Some((m, σ)) = self.find_morphism( &t, target_type ) {
|
||||
if let Some((m, σ)) = self.find_morphism( repr_tree.read().unwrap().get_type(), target_type ) {
|
||||
(m.repr_tree_op)( repr_tree.clone(), &σ );
|
||||
} else {
|
||||
eprintln!("could not find morphism");
|
||||
|
|
|
|||
|
|
@ -107,4 +107,3 @@ impl TerminalEvent {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ use {
|
|||
nested::{
|
||||
repr_tree::{Context, ReprTree},
|
||||
editors::list::*,
|
||||
edit_tree::{TreeCursor, TreeNav, TreeNavResult, EditTree},
|
||||
edit_tree::{TreeCursor, TreeNav, TreeNavResult, NestedNode},
|
||||
},
|
||||
crate::{
|
||||
DisplaySegment,
|
||||
|
|
@ -91,7 +91,7 @@ impl PTYListStyle {
|
|||
.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
|
||||
.write().unwrap()
|
||||
.insert_branch(ReprTree::new_leaf(
|
||||
|
|
@ -135,11 +135,10 @@ impl PTYListController {
|
|||
}
|
||||
|
||||
pub fn for_node(
|
||||
node: &mut EditTree,
|
||||
node: &mut NestedNode,
|
||||
split_char: Option<char>,
|
||||
close_char: Option<char>
|
||||
) {
|
||||
/*
|
||||
{
|
||||
let ctx = node.ctx.as_ref();
|
||||
let mut ctx = ctx.write().unwrap();
|
||||
|
|
@ -151,15 +150,15 @@ impl PTYListController {
|
|||
ctx.meta_chars.push(*c);
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
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() )));
|
||||
|
||||
node.ctrl.cmd.set(Some(controller.clone()));
|
||||
node.ctrl.close_char.set(close_char);
|
||||
node.edit.cmd.set(Some(controller.clone()));
|
||||
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()
|
||||
}
|
||||
|
||||
|
|
@ -167,7 +166,7 @@ impl PTYListController {
|
|||
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()
|
||||
}
|
||||
|
||||
|
|
@ -220,27 +219,26 @@ impl PTYListController {
|
|||
|
||||
match cur.mode {
|
||||
ListCursorMode::Insert => {
|
||||
let rt = ReprTree::new_arc(e.typ.clone());
|
||||
let new_edittree = ctx.setup_edittree(
|
||||
rt,
|
||||
self.depth.map(|d| d+1)
|
||||
);
|
||||
let mut ne = new_edittree.write().unwrap();
|
||||
match ne.send_cmd_obj(cmd_obj.clone()) {
|
||||
/* TODO
|
||||
let mut new_edit = Context::make_node(&e.ctx, e.typ.clone(), self.depth.map(|d| d+1)).unwrap();
|
||||
new_edit.goto(TreeCursor::home());
|
||||
|
||||
match new_edit.send_cmd_obj(cmd_obj.clone()) {
|
||||
TreeNavResult::Continue => {
|
||||
drop(ne);
|
||||
e.insert(new_edittree.clone());
|
||||
e.insert(Arc::new(RwLock::new(new_edit.clone())));
|
||||
TreeNavResult::Continue
|
||||
}
|
||||
TreeNavResult::Exit => {
|
||||
TreeNavResult::Exit
|
||||
}
|
||||
}
|
||||
*/
|
||||
TreeNavResult::Continue
|
||||
},
|
||||
ListCursorMode::Select => {
|
||||
if let Some(item) = e.get_item_mut() {
|
||||
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 {
|
||||
TreeNavResult::Continue => TreeNavResult::Continue,
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ pub mod list;
|
|||
|
||||
use {
|
||||
nested::{
|
||||
edit_tree::{EditTree},
|
||||
edit_tree::{NestedNode},
|
||||
repr_tree::{ReprTree, Context}
|
||||
},
|
||||
r3vi::{
|
||||
|
|
@ -13,22 +13,22 @@ use {
|
|||
crate::{
|
||||
make_label,
|
||||
DisplaySegment,
|
||||
atom::{TerminalAtom, TerminalStyle}
|
||||
atom::TerminalAtom
|
||||
}
|
||||
};
|
||||
|
||||
pub fn edittree_make_char_view(
|
||||
node: EditTree
|
||||
) -> EditTree {
|
||||
/*
|
||||
pub fn node_make_char_view(
|
||||
node: NestedNode
|
||||
) -> NestedNode {
|
||||
node.disp.view
|
||||
.write().unwrap()
|
||||
.insert_branch(ReprTree::new_leaf(
|
||||
Context::parse(&node.ctx, "TerminalView"),
|
||||
node.get_edit::< nested::editors::char::CharEditor >()
|
||||
.unwrap()
|
||||
node.data
|
||||
.read()
|
||||
.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 }))
|
||||
.to_grid()
|
||||
.into(),
|
||||
|
|
@ -37,46 +37,19 @@ pub fn edittree_make_char_view(
|
|||
node
|
||||
}
|
||||
|
||||
pub fn edittree_make_digit_view(
|
||||
node: EditTree
|
||||
) -> EditTree {
|
||||
pub fn node_make_seq_view(
|
||||
mut node: NestedNode
|
||||
) -> NestedNode {
|
||||
node.disp.view
|
||||
.write().unwrap()
|
||||
.insert_branch(ReprTree::new_leaf(
|
||||
Context::parse(&node.ctx, "TerminalView"),
|
||||
node.get_edit::< nested::editors::integer::DigitEditor >()
|
||||
.unwrap()
|
||||
node.data
|
||||
.read()
|
||||
.unwrap()
|
||||
.get_data_port()
|
||||
.map(move |digit|
|
||||
match digit {
|
||||
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()
|
||||
)
|
||||
.get_port::<dyn SequenceView<Item = NestedNode>>()
|
||||
.expect("unable to get Seq-view")
|
||||
.map(move |char_node| node_make_tty_view(char_node.clone()).display_view() )
|
||||
.wrap(make_label("("), make_label(")"))
|
||||
.to_grid_horizontal()
|
||||
.flatten()
|
||||
|
|
@ -84,4 +57,28 @@ pub fn edittree_make_seq_view(
|
|||
));
|
||||
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
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ pub trait DisplaySegment {
|
|||
use nested::repr_tree::Context;
|
||||
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> {
|
||||
if let Some( tv_repr ) = self.disp.view
|
||||
.read().unwrap()
|
||||
|
|
@ -56,10 +56,10 @@ impl DisplaySegment for nested::edit_tree::EditTree {
|
|||
}
|
||||
|
||||
else {
|
||||
make_label("# could not get ViewPort #")
|
||||
make_label("?")
|
||||
}
|
||||
} else {
|
||||
make_label("# No TTY View available #")
|
||||
make_label("?")
|
||||
.map_item(|_p,a| a.add_style_back(TerminalStyle::fg_color((220, 30, 30))))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
use {
|
||||
cgmath::Vector2,
|
||||
nested::{
|
||||
edit_tree::EditTree,
|
||||
edit_tree::NestedNode,
|
||||
repr_tree::{Context, ReprTree},
|
||||
},
|
||||
crate::{
|
||||
|
|
|
|||
|
|
@ -1,12 +1,11 @@
|
|||
[package]
|
||||
authors = ["Michael Sippel <micha@fragmental.art>"]
|
||||
name = "pty-server"
|
||||
name = "ansi_parser"
|
||||
version = "0.1.0"
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
nested = { path = "../lib-nested-core" }
|
||||
nested-tty = { path = "../lib-nested-tty" }
|
||||
nested = { path = "../../nested" }
|
||||
cgmath = { version = "0.18.0", features = ["serde"] }
|
||||
serde = { version = "1.0", features = ["serde_derive"] }
|
||||
bincode = "1.3.3"
|
||||
|
|
|
|||
Loading…
Reference in a new issue