node: ViewPort for editor, cleanup PTYListEditor

- move split/join functions into ListEditor
- separate PTYListStyle and PTYListController

nested/src/editors/integer/editor.rs

@@ -12,7 +12,7 @@ use {
     },
     crate::{
         type_system::{Context, TypeTerm, ReprTree},
-        editors::list::{PTYListEditor},
+        editors::list::{ListEditor, PTYListController, PTYListStyle},
         terminal::{
             TerminalAtom, TerminalEvent, TerminalStyle, make_label
         },
@@ -114,7 +114,7 @@ impl DigitEditor {
 
     pub fn get_type(&self) -> TypeTerm {
         TypeTerm::Type {
-            id: self.ctx.read().unwrap().get_typeid("Digit").unwrap(),
+            id: self.ctx.read().unwrap().get_fun_typeid("Digit").unwrap(),
             args: vec![
                 TypeTerm::Num(self.radix as i64).into()
             ]
@@ -140,38 +140,31 @@ pub struct PosIntEditor {
 
 impl PosIntEditor {
     pub fn new(ctx: Arc<RwLock<Context>>, radix: u32) -> Self {
-        let editor = PTYListEditor::new(
+        let mut node = Context::make_node(&ctx, (&ctx, format!("( List ( Digit {} ) )", radix).as_str()).into(), 0).unwrap();
-            ctx.clone(),
-            TypeTerm::Type {
-                id: ctx.read().unwrap().get_typeid("Digit").unwrap(),
-                args: vec![
-                    TypeTerm::Num(radix as i64).into()
-                ]
-            },
-            None,
-            0
-        );
 
-            let view = editor.pty_view((
+        PTYListController::for_node( &mut node, Some(' '), None );
+        PTYListStyle::for_node( &mut node,
+            (
                 match radix {
                     2 => "0d".into(),
                     16 => "0x".into(),
                     _ => "".into()
                 },
                 "".into(),
-                "".into()));
+                "".into()
-            let mut node = editor.into_node().set_view(view);
+            )
+        );
 
         // Set Type
         let data = node.data.clone().unwrap();
         node = node.set_data(ReprTree::ascend(
             &data,
             TypeTerm::Type {
-                id: ctx.read().unwrap().get_typeid("PosInt").unwrap(),
+                id: ctx.read().unwrap().get_fun_typeid("PosInt").unwrap(),
                 args: vec![
                     TypeTerm::Num(radix as i64).into(),
                     TypeTerm::Type {
-                        id: ctx.read().unwrap().get_typeid("BigEndian").unwrap(),
+                        id: ctx.read().unwrap().get_fun_typeid("BigEndian").unwrap(),
                         args: vec![]
                     }.into()
                 ]

nested/src/editors/integer/mod.rs

@@ -7,3 +7,4 @@ pub use {
     editor::{DigitEditor, PosIntEditor},
     radix::RadixProjection,
 };
+

nested/src/editors/list/editor.rs

@@ -1,12 +1,13 @@
 use {
     r3vi::{
-        view::{OuterViewPort, singleton::*, sequence::*},
+        view::{port::UpdateTask, OuterViewPort, singleton::*, sequence::*},
         buffer::{singleton::*, vec::*}
     },
     crate::{
         type_system::{Context, TypeTerm, ReprTree},
         editors::list::{ListCursor, ListCursorMode},
-        tree::{NestedNode, TreeNav}
+        tree::{NestedNode, TreeNav, TreeCursor},
+        diagnostics::Diagnostics
     },
     std::sync::{Arc, RwLock}
 };
@@ -27,6 +28,31 @@ pub struct ListEditor {
 }
 
 impl ListEditor {
+    pub fn init_ctx(ctx: &Arc<RwLock<Context>>) {
+        let mut ctx = ctx.write().unwrap();
+
+        ctx.add_list_typename("List".into());
+        ctx.add_node_ctor(
+            "List", Arc::new(
+                |ctx: Arc<RwLock<Context>>, ty: TypeTerm, depth: usize| {
+                    match ty {
+                        TypeTerm::Type {
+                            id: _, args
+                        } => {
+                            if args.len() > 0 {
+                                let typ = (args[0].clone().0)[0].clone();
+                                Some(ListEditor::new(ctx, typ).into_node(depth))
+                            } else {
+                                None
+                            }
+                        }
+                        _ => None
+                    }
+                }
+            )
+        );
+    }
+
     pub fn new(
         ctx: Arc<RwLock<Context>>,
         typ: TypeTerm,
@@ -92,30 +118,33 @@ impl ListEditor {
         let ctx = self.ctx.clone();
         let editor = Arc::new(RwLock::new(self));
 
+        let e = editor.read().unwrap();
+
         NestedNode::new(depth)
             .set_ctx(ctx)
             .set_data(data)
             .set_editor(editor.clone())
             .set_nav(editor.clone())
            //.set_cmd(editor.clone())
+            .set_diag(e
+                      .get_data_port()
+                      .enumerate()
+                      .map(
+                          |(idx, item_editor)| {
+                              let idx = *idx;
+                              item_editor
+                                  .get_msg_port()
+                                  .map(
+                                      move |msg| {
+                                          let mut msg = msg.clone();
+                                          msg.addr.insert(0, idx);
+                                          msg
                                       }
-
+                                  )
-    pub fn new_node(
+                          }
-        node: NestedNode,
+                      )
-        item_type: TypeTerm
+                      .flatten()
-    ) -> NestedNode {
+            )
-        let ctx = node.ctx.clone().unwrap();
-
-        let editor = ListEditor::new(
-            ctx.clone(),
-            item_type,
-        );
-        let data = editor.get_data();
-        let editor = Arc::new(RwLock::new(editor));
-
-        node.set_data(data)
-            .set_editor(editor.clone())
-            .set_nav(editor.clone())
     }
 
     pub fn get_item_type(&self) -> TypeTerm {
@@ -124,7 +153,7 @@ impl ListEditor {
 
     pub fn get_seq_type(&self) -> TypeTerm {
         TypeTerm::Type {
-            id: self.ctx.read().unwrap().get_typeid("List").unwrap(),
+            id: self.ctx.read().unwrap().get_fun_typeid("List").unwrap(),
             args: vec![ self.get_item_type().into() ]
         }
     }
@@ -255,8 +284,10 @@ impl ListEditor {
                     let prev_node = self.data.get(prev_idx);
 
                     if let Some(prev_editor) = prev_node.editor.clone() {
-                        let prev_editor = prev_editor.downcast::<RwLock<ListEditor>>().unwrap();
+                        prev_editor.0.update();
+                        let prev_editor = prev_editor.get_view().unwrap().get().unwrap().downcast::<RwLock<ListEditor>>().unwrap();
                         let prev_editor = prev_editor.write().unwrap();
+                        prev_editor.get_data_port().0.update();
 
                         if prev_editor.get_data_port().get_view().unwrap().iter()
                             .filter_map(|x| x.get_data_view::<dyn SingletonView<Item = Option<char>>>(vec![].into_iter())?.get()).count() == 0
@@ -305,6 +336,110 @@ impl ListEditor {
             self.data.push(other.data.get(i));
         }
     }
+
+
+    pub fn listlist_split(&mut self) {
+        let cur = self.get_cursor();
+        if let Some(item) = self.get_item_mut() {
+            let depth = item.depth;
+
+            if let Some(head_editor) = item.editor.clone() {
+
+                head_editor.0.update();
+                let head = head_editor.get_view().unwrap().get().unwrap().downcast::<RwLock<ListEditor>>().unwrap();
+                let mut head = head.write().unwrap();
+
+                if head.data.len() > 0 {
+
+                    if cur.tree_addr.len() > 2 {
+                        head.listlist_split();
+                    }
+
+                    let mut tail = head.split();
+
+                    head.goto(TreeCursor::none());
+
+                    tail.cursor.set(
+                        ListCursor {
+                            idx: Some(0),
+                            mode: if cur.tree_addr.len() > 2 {
+                                ListCursorMode::Select
+                            } else {
+                                ListCursorMode::Insert
+                            }
+                        }
+                    );
+
+                    let item_type =
+                        if let Some(data) = item.data.clone() {
+                            let data = data.read().unwrap();
+                            Some(data.get_type().clone())
+                        } else {
+                            None
+                        };
+
+                    let mut tail_node = tail.into_node(depth);
+                    tail_node = tail_node.set_ctx(item.ctx.clone().unwrap());
+
+                    //                    if let Some(item_type) = item_type {
+                        tail_node = tail_node.morph(self.typ.clone());
+                    //}
+                    
+                    self.insert(
+                        tail_node
+                    );
+                }
+            }
+        }
+    }
+
+    pub fn listlist_join_pxev(&mut self, idx: isize, item: &NestedNode) {
+        {
+            let prev_editor = self.data.get_mut(idx as usize-1);
+            let prev_editor = prev_editor.editor.clone();
+            if let Some(prev_editor) = prev_editor {
+                prev_editor.0.update();
+                if let Ok(prev_editor) = prev_editor.get_view().unwrap().get().unwrap().downcast::<RwLock<ListEditor>>() {
+                    let mut prev_editor = prev_editor.write().unwrap();
+
+                    let cur_editor = item.editor.clone().unwrap();
+                    cur_editor.0.update();
+                    let cur_editor = cur_editor.get_view().unwrap().get().unwrap().downcast::<RwLock<ListEditor>>().unwrap();
+                    let cur_editor = cur_editor.write().unwrap();
+
+                    prev_editor.join(&cur_editor);
+                    
+                    self.cursor.set(
+                        ListCursor {
+                            idx: Some(idx - 1), mode: ListCursorMode::Select
+                        }
+                    );
+
+                }
+            }
+        }
+
+        self.data.remove(idx as usize);
+    }
+
+    pub fn listlist_join_nexd(&mut self, next_idx: usize, item: &NestedNode) {
+        {
+            let next_editor = self.data.get_mut(next_idx).editor.clone();
+            if let Some(next_editor) = next_editor {
+                next_editor.0.update();
+                if let Ok(next_editor) = next_editor.get_view().unwrap().get().unwrap().downcast::<RwLock<ListEditor>>() {
+                    let mut next_editor = next_editor.write().unwrap();
+                    let cur_editor = item.editor.clone().unwrap();
+                    cur_editor.0.update();
+                    let cur_editor = cur_editor.get_view().unwrap().get().unwrap().downcast::<RwLock<ListEditor>>().unwrap();
+                    let mut cur_editor = cur_editor.write().unwrap();
+
+                    cur_editor.join(&next_editor);
+                }
+            }
+        }
+        self.data.remove(next_idx);
+    }
 }
 /*
 use crate::{

nested/src/editors/list/mod.rs

@@ -10,6 +10,6 @@ pub use {
     cursor::{ListCursor, ListCursorMode},
     editor::ListEditor,
     segment::{ListSegment, ListSegmentSequence},
-    pty_editor::{PTYListEditor}
+    pty_editor::{PTYListStyle, PTYListController}
 };
 

nested/src/editors/list/pty_editor.rs

@@ -18,56 +18,30 @@ use {
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-pub struct PTYListEditor {
+pub struct PTYListStyle {
-    pub editor: Arc<RwLock<ListEditor>>,
+    style: (String, String, String),
-    split_char: Option<char>,
     depth: usize
 }
 
-//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
+impl PTYListStyle {
-
+    pub fn new(style: (&str, &str, &str), depth: usize) -> PTYListStyle {
-impl PTYListEditor {
+        PTYListStyle {
-    pub fn new(
+            style: (style.0.into(), style.1.into(), style.2.into()),
-        ctx: Arc<RwLock<Context>>,
-        typ: TypeTerm,
-        split_char: Option<char>,
-        depth: usize
-    ) -> Self {
-        Self::from_editor(
-            Arc::new(RwLock::new(ListEditor::new(ctx, typ))),
-            split_char,
             depth
-        )
-    }
-
-    pub fn from_editor(
-        editor: Arc<RwLock<ListEditor>>,
-        split_char: Option<char>,
-        depth: usize
-    ) -> Self {
-        PTYListEditor {
-            split_char,
-            depth,
-            editor,
         }
     }
 
-    pub fn get_seg_seq_view(&self) -> OuterViewPort<dyn SequenceView<Item = OuterViewPort<dyn TerminalView>>> {
+    pub fn get_seg_seq_view(&self, editor: &ListEditor) -> OuterViewPort<dyn SequenceView<Item = OuterViewPort<dyn TerminalView>>> {
         let seg_seq = ListSegmentSequence::new(
-            self.editor.read().unwrap().get_cursor_port(),
+            editor.get_cursor_port(),
-            self.editor.read().unwrap().get_data_port(),
+            editor.get_data_port(),
             self.depth
         );
         let se = seg_seq.read().unwrap();
         se.get_view().map(move |segment| segment.pty_view())
     }
 
-    pub fn pty_view(
+    pub fn pty_view(&self, editor: &ListEditor) -> OuterViewPort<dyn TerminalView> {
-        &self,
-        display_style: (&str, &str, &str),
-    ) -> OuterViewPort<dyn TerminalView> {
-        let editor = self.editor.read().unwrap();
-
         let seg_seq = ListSegmentSequence::new(
             editor.get_cursor_port(),
             editor.get_data_port(),
@@ -78,44 +52,59 @@ impl PTYListEditor {
         seg_seq
             .get_view()
             .map(move |segment| segment.pty_view())
-            .separate(make_label(display_style.1))
+            .separate(make_label(&self.style.1))
-            .wrap(make_label(display_style.0), make_label(display_style.2))
+            .wrap(make_label(&self.style.0), make_label(&self.style.2))
             .to_grid_horizontal()
             .flatten()
     }
 
-    pub fn into_node(self) -> NestedNode {
+    pub fn for_node(node: &mut NestedNode, style: (&str, &str, &str)) {
-        let depth = self.depth;
+        node.view = Some(
-        let editor = Arc::new(RwLock::new(self));
+            Self::new(style, node.depth)
-
+                .pty_view(
-        let ed = editor.read().unwrap();
+                    &node.get_edit::<ListEditor>().unwrap().read().unwrap()
-        let edd = ed.editor.read().unwrap();
+                )
-   
+        );
-        NestedNode::new(depth)
-            .set_data(edd.get_data())
-            .set_cmd(editor.clone())
-            .set_editor(ed.editor.clone())
-            .set_nav(ed.editor.clone())
-            .set_ctx(edd.ctx.clone())
-            .set_diag(
-                edd.get_data_port()
-                    .enumerate()
-                    .map(
-                        |(idx, item_editor)| {
-                            let idx = *idx;
-                            item_editor
-                                .get_msg_port()
-                                .map(
-                                    move |msg| {
-                                        let mut msg = msg.clone();
-                                        msg.addr.insert(0, idx);
-                                        msg
     }
-                                )
 }
-                    )
+
-                .flatten()
+//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-            )
+
+pub struct PTYListController {
+    pub editor: Arc<RwLock<ListEditor>>,
+
+    split_char: Option<char>,
+    close_char: Option<char>,
+
+    depth: usize
+}
+
+//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
+
+impl PTYListController {
+    pub fn from_editor(
+        editor: Arc<RwLock<ListEditor>>,
+        split_char: Option<char>,
+        close_char: Option<char>,
+        depth: usize
+    ) -> Self {
+        PTYListController {
+            editor,
+            split_char,
+            close_char,
+            depth
+        } 
+    }
+
+    pub fn for_node(
+        node: &mut NestedNode,
+        split_char: Option<char>,
+        close_char: Option<char>
+    ) {
+        let editor = node.get_edit::<ListEditor>().unwrap();
+        let controller = Arc::new(RwLock::new(PTYListController::from_editor( editor, split_char, close_char, node.depth )));
+
+        node.cmd = Some(controller.clone());
     }
 
     pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = NestedNode>> {
@@ -133,113 +122,16 @@ impl PTYListEditor {
     pub fn set_depth(&mut self, depth: usize) {
         self.depth = depth;
     }
-
-    pub fn split(e: &mut ListEditor) {
-        let cur = e.get_cursor();
-        if let Some(item) = e.get_item_mut() {
-            let depth = item.depth;
-
-            if let Some(head_editor) = item.editor.clone() {
-
-                let head = head_editor.downcast::<RwLock<ListEditor>>().unwrap();
-                let mut head = head.write().unwrap();
-
-                if head.data.len() > 0 {
-
-                    if cur.tree_addr.len() > 2 {
-                        PTYListEditor::split(&mut head);
-                    }
-
-                    let mut tail = head.split();
-
-                    head.goto(TreeCursor::none());
-
-                    tail.cursor.set(
-                        ListCursor {
-                            idx: Some(0),
-                            mode: if cur.tree_addr.len() > 2 {
-                                ListCursorMode::Select
-                            } else {
-                                ListCursorMode::Insert
-                            }
-                        }
-                    );
-
-                    let item_type =
-                        if let Some(data) = item.data.clone() {
-                            let data = data.read().unwrap();
-                            Some(data.get_type().clone())
-                        } else {
-                            None
-                        };
-
-                    let mut tail_node = tail.into_node(depth);
-                    tail_node = tail_node.set_ctx(item.ctx.clone().unwrap());
-
-                    if let Some(item_type) = item_type {
-                        tail_node = tail_node.morph(item_type);
-                    }
-                    
-                    e.insert(
-                        tail_node
-                    );
-                }
-            }
-        }
-    }
-
-    fn join_pxev(e: &mut ListEditor, idx: isize, item: &NestedNode) {
-        {
-            let prev_editor = e.data.get_mut(idx as usize-1);
-            let prev_editor = prev_editor.editor.clone();
-            if let Some(prev_editor) = prev_editor {
-                if let Ok(prev_editor) = prev_editor.downcast::<RwLock<ListEditor>>() {
-                    let mut prev_editor = prev_editor.write().unwrap();
-
-                    let cur_editor = item.editor.clone().unwrap();
-                    let cur_editor = cur_editor.downcast::<RwLock<ListEditor>>().unwrap();
-                    let cur_editor = cur_editor.write().unwrap();
-
-                    prev_editor.join(&cur_editor);
-                    
-                    e.cursor.set(
-                        ListCursor {
-                            idx: Some(idx - 1), mode: ListCursorMode::Select
-                        }
-                    );
-
-                }
-            }
-        }
-
-        e.data.remove(idx as usize);
-    }
-
-    fn join_nexd(e: &mut ListEditor, next_idx: usize, item: &NestedNode) {
-        {
-            let next_editor = e.data.get_mut(next_idx).editor.clone();
-            if let Some(next_editor) = next_editor {
-                if let Ok(next_editor) = next_editor.downcast::<RwLock<ListEditor>>() {
-                    let mut next_editor = next_editor.write().unwrap();
-                    let cur_editor = item.editor.clone().unwrap();
-                    let cur_editor = cur_editor.downcast::<RwLock<ListEditor>>().unwrap();
-                    let mut cur_editor = cur_editor.write().unwrap();
-
-                    cur_editor.join(&next_editor);
-                }
-            }
-        }
-        e.data.remove(next_idx);
-    }
 }
 
 use r3vi::view::singleton::SingletonView;
 use crate::commander::ObjCommander;
 
-impl ObjCommander for PTYListEditor {
+impl ObjCommander for PTYListController {
     fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult {
         let mut e = self.editor.write().unwrap();
         let cur = e.cursor.get();
+        let cur_depth = e.get_cursor().tree_addr.len();
 
         let ctx = e.ctx.clone();
         let ctx = ctx.read().unwrap();
@@ -247,8 +139,24 @@ impl ObjCommander for PTYListEditor {
         let co = cmd_obj.read().unwrap();
         let cmd_type = co.get_type().clone();
         let term_event_type = ctx.type_term_from_str("( TerminalEvent )").unwrap();
+        let nested_node_type = ctx.type_term_from_str("( NestedNode )").unwrap();
         let char_type = ctx.type_term_from_str("( Char )").unwrap();
 
+        if cmd_type == nested_node_type {
+            if let Some(node_view) = co.get_view::<dyn SingletonView<Item = NestedNode>>() {
+                if let Some(idx) = cur.idx {
+                    match cur.mode {
+                        ListCursorMode::Select => {
+                            *e.data.get_mut(idx as usize) = node_view.get();
+                        }
+                        ListCursorMode::Insert => {
+                            e.data.insert(idx as usize, node_view.get());
+                        }
+                    }
+                }
+            }
+        }
+
         if cmd_type == term_event_type {
             if let Some(te_view) = co.get_view::<dyn SingletonView<Item = TerminalEvent>>() {
                 drop(co);
@@ -309,7 +217,7 @@ impl ObjCommander for PTYListEditor {
                                                             |is_zero, x| is_zero && (*x == 0)
                                                         )
                                                     {
-                                                        PTYListEditor::join_pxev(&mut e, idx, &item);
+                                                        e.listlist_join_pxev(idx, &item);
 
                                                         /* Optional: recursive joining
                                                         
@@ -333,7 +241,7 @@ impl ObjCommander for PTYListEditor {
                                                             |is_end, x| is_end && (*x == -1)
                                                         )
                                                     {
-                                                        PTYListEditor::join_nexd(&mut e, next_idx, &item);
+                                                        e.listlist_join_nexd(next_idx, &item);
 
                                                         /* Optional: recursive joining
 
@@ -351,7 +259,7 @@ impl ObjCommander for PTYListEditor {
 
                                                 TerminalEvent::Input(Event::Key(Key::Char(c))) => {
                                                     if Some(c) == self.split_char {
-                                                        PTYListEditor::split(&mut e);
+                                                        e.listlist_split();
                                                         TreeNavResult::Continue
                                                     } else {
                                                         item.send_cmd_obj(cmd_obj)
@@ -382,14 +290,18 @@ impl ObjCommander for PTYListEditor {
                 drop(co);
                 let c = cmd_view.get();
 
-                if Some(c) == self.split_char {
+                if Some(c) == self.split_char && cur_depth == 2 {
-                    PTYListEditor::split(&mut e);
+                    e.listlist_split();
                     TreeNavResult::Continue
                 } else {
                     if let Some(mut item) = e.get_item_mut() {
                         match item.send_cmd_obj(cmd_obj) {
                             TreeNavResult::Continue => TreeNavResult::Continue,
                             TreeNavResult::Exit => {
+                                if Some(c) == self.split_char {                                
+                                    e.listlist_split();
+                                }
+
                                 item.goto(TreeCursor::none());
                                 e.cursor.set(ListCursor {
                                     mode: ListCursorMode::Insert,

nested/src/tree/node.rs

@@ -24,7 +24,7 @@ pub struct NestedNode {
     pub ctx: Option<Arc<RwLock<Context>>>,
 
     /// abstract editor
-    pub editor: Option<Arc<dyn Any + Send + Sync>>,
+    pub editor: Option<OuterViewPort<dyn SingletonView<Item = Option<Arc<dyn Any + Send + Sync>>>>>,
 
     /// abstract data view
     pub data: Option<Arc<RwLock<ReprTree>>>,
@@ -195,7 +195,7 @@ impl NestedNode {
     }
 
     pub fn set_editor(mut self, editor: Arc<dyn Any + Send + Sync>) -> Self {
-        self.editor = Some(editor);
+        self.editor = Some(SingletonBuffer::new(Some(editor)).get_port());
         self
     }
 
@@ -267,7 +267,7 @@ impl NestedNode {
 */
     pub fn get_edit<T: Send + Sync + 'static>(&self) -> Option<Arc<RwLock<T>>> {
         if let Some(edit) = self.editor.clone() {
-            if let Ok(edit) = edit.downcast::<RwLock<T>>() {
+            if let Ok(edit) = edit.get_view().unwrap().get().unwrap().downcast::<RwLock<T>>() {
                 Some(edit)
             } else {
                 None

nested/src/type_system/make_editor.rs

@@ -61,38 +61,13 @@ pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
             }
         )
     );
+
     ctx.write().unwrap().add_list_typename("Seq".into());
     ctx.write().unwrap().add_list_typename("Sequence".into());
+    ctx.write().unwrap().add_list_typename("SepSeq".into());
+    ctx.write().unwrap().add_typename("NestedNode".into());
 
-    ctx.write().unwrap().add_list_typename("List".into());
+    ListEditor::init_ctx( &ctx );
-    ctx.write().unwrap().add_node_ctor(
-        "List", Arc::new(
-            |ctx: Arc<RwLock<Context>>, ty: TypeTerm, depth: usize| {
-                match ty {
-                    TypeTerm::Type {
-                        id: _, args
-                    } => {
-                        if args.len() > 0 {
-                            let editor = PTYListEditor::new(
-                                ctx,
-                                (args[0].clone().0)[0].clone(),
-                                Some(','),
-                                depth + 1
-                            );
-                            let view = editor.pty_view(("{",", ", "}"));
-
-                            Some(editor
-                                    .into_node()
-                                    .set_view(view))
-                        } else {
-                            None
-                        }
-                    }
-                    _ => None
-                }
-            }
-        )
-    );
 
     ctx.write().unwrap().add_list_typename("Symbol".into());
     let pattern = MorphismTypePattern {
@@ -102,16 +77,8 @@ pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
     ctx.write().unwrap().add_morphism(pattern,
         Arc::new(
             |mut node, _dst_type:_| {
-                let depth = node.depth;
+                PTYListController::for_node( &mut node, None, None );
-                let editor = node.editor.clone().unwrap().downcast::<RwLock<ListEditor>>().unwrap();
+                PTYListStyle::for_node( &mut node, ("","","") );
-                let pty_editor = PTYListEditor::from_editor(
-                    editor,
-                    None,
-                    depth
-                );
-
-                node.view = Some(pty_editor.pty_view(("", "", "")));
-                node.cmd = Some(Arc::new(RwLock::new(pty_editor)));
                 Some(node)
             }
         )
@@ -123,7 +90,7 @@ pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
                 let mut node = Context::make_node(
                     &ctx,
                     TypeTerm::Type {
-                        id: ctx.read().unwrap().get_typeid("List").unwrap(),
+                        id: ctx.read().unwrap().get_fun_typeid("List").unwrap(),
                         args: vec![
                             TypeTerm::new(ctx.read().unwrap().get_typeid("Char").unwrap()).into()
                         ]
@@ -146,20 +113,8 @@ pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
     ctx.write().unwrap().add_morphism(pattern,
         Arc::new(
             |mut node, _dst_type:_| {
-                let depth = node.depth;
+                PTYListController::for_node( &mut node, None, Some('\"') );
-                let editor = node.editor.clone().unwrap().downcast::<RwLock<ListEditor>>().unwrap();
+                PTYListStyle::for_node( &mut node, ("\"","","\"") );
-                let pty_editor = PTYListEditor::from_editor(
-                    editor,
-                    None,
-                    depth
-                );
-
-                node.view = Some(pty_editor.pty_view((
-                    "\"".into(),
-                    "".into(),
-                    "\"".into()
-                )));
-                node.cmd = Some(Arc::new(RwLock::new(pty_editor)));
                 Some(node)                
             }
         )
@@ -171,7 +126,7 @@ pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
                 let mut node = Context::make_node(
                     &ctx,
                     TypeTerm::Type {
-                        id: ctx.read().unwrap().get_typeid("List").unwrap(),
+                        id: ctx.read().unwrap().get_fun_typeid("List").unwrap(),
                         args: vec![
                             TypeTerm::new(ctx.read().unwrap().get_typeid("Char").unwrap()).into()
                         ]
@@ -243,7 +198,7 @@ pub fn init_math_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
         Arc::new(
             |mut node, dst_type| {
                 let depth = node.depth;
-                let editor = node.editor.clone().unwrap().downcast::<RwLock<ListEditor>>().unwrap();
+                let editor = node.editor.clone().unwrap().get_view().unwrap().get().unwrap().downcast::<RwLock<ListEditor>>().unwrap();
 
                 // todo: check src_type parameter to be ( Digit radix )
                 
@@ -254,21 +209,17 @@ pub fn init_math_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
                         if args.len() > 0 {
                             match (args[0].0)[0] {
                                 TypeTerm::Num(_radix) => {
-                                    let pty_editor = PTYListEditor::from_editor(
+                                    PTYListController::for_node(
-                                        editor,
+                                        &mut node,
                                         Some(','),
-                                        depth
+                                        None,
+                                    );
+
+                                    PTYListStyle::for_node(
+                                        &mut node,
+                                        ("0d", "", "")
                                     );
 
-                                    // todo: set data view
-                                    node.view = Some(pty_editor.pty_view(
-                                        (
-                                            "{".into(),
-                                            ", ".into(),
-                                            "}".into()
-                                        )
-                                    ));
-                                    node.cmd = Some(Arc::new(RwLock::new(pty_editor)));
                                     Some(node)
                                 },
                                 _ => None
@@ -297,7 +248,7 @@ pub fn init_math_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
                                     let mut node = Context::make_node(
                                         &ctx,
                                         TypeTerm::Type {
-                                            id: ctx.read().unwrap().get_typeid("List").unwrap(),
+                                            id: ctx.read().unwrap().get_fun_typeid("List").unwrap(),
                                             args: vec![
                                                 TypeTerm::new(ctx.read().unwrap().get_typeid("Digit").unwrap())
                                                     .num_arg(radix)