Remove references to CMark namespece on public API

src/lib/MarkdownView.vala

@@ -11,7 +11,7 @@ namespace GtkCommonMark {
 
         private int allocated_width = MIN_WIDTH;
 
-        public signal void widget_embedded(MarkdownViewEmbeddedWidgetHost widget_host, CMark.Node node);
+        public signal void widget_embedded(MarkdownViewEmbeddedWidgetHost widget_host, string url, string text);
         public signal void link_activated(string url);
 
         public MarkdownView() {
@@ -47,9 +47,7 @@ namespace GtkCommonMark {
         public void load_from_file_stream(FileStream stream) {
             var reader = new GtkCommonMark.Reader(buffer, this, tag_manager);
             reader.widget_embedded.connect(on_widget_embedded);
-            var root = CMark.Node.parse_file (stream, CMark.OPT.DEFAULT);
-            reader.append_node (root);
-            print("Read!\n");
+            reader.read_file(stream);
         }
 
         public void load_from_file(File file) {
@@ -57,6 +55,18 @@ namespace GtkCommonMark {
             load_from_file_stream(stream);
         }
 
+        public void load_from_stream(InputStream stream) throws IOError {
+            var reader = new GtkCommonMark.Reader(buffer, this, tag_manager);
+            reader.widget_embedded.connect(on_widget_embedded);
+            
+            var buffer = new uint8[1048576]; // TODO read properly in loop
+            size_t bytes_read;
+            stream.read_all(buffer, out bytes_read);
+            buffer.length = (int)bytes_read;
+            
+            reader.read_data(buffer);
+        }
+
         protected string? link_at_buffer_location(int x, int y) {
             Gtk.TextIter iter;
             get_iter_at_location(out iter, x, y);
@@ -94,11 +104,11 @@ namespace GtkCommonMark {
             }
         }
 
-        protected virtual void on_widget_embedded(MarkdownViewEmbeddedWidgetHost host, CMark.Node node) {
+        protected virtual void on_widget_embedded(MarkdownViewEmbeddedWidgetHost host, NodeInfo node) {
             host.set_available_width(calculate_embed_size(allocated_width));
             available_size_for_embed_changed.connect(w => host.set_available_width(w));
-            if(node.get_type() == CMark.NODE_TYPE.IMAGE) {
-                widget_embedded(host, node);
+            if(node.node_type == NodeType.IMAGE) {
+                widget_embedded(host, node.url, node.title);
             }
         }
 

src/lib/NodeActions/Break.vala

@@ -2,7 +2,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class Break : SimpleNodeAction {
 
-        public Break(CMark.Node node) {
+        public Break(NodeInfo node) {
             base(node);
         }
 

src/lib/NodeActions/Code.vala

@@ -2,7 +2,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class Code : SimpleNodeAction {
 
-        public Code(CMark.Node node) {
+        public Code(NodeInfo node) {
             base(node);
         }
 
@@ -11,7 +11,7 @@ namespace GtkCommonMark.NodeActions {
         }
 
         public override void at_start(Gtk.TextBuffer buffer, ref Gtk.TextIter iter) {
-            var literal = node.get_literal();
+            var literal = node.literal;
             if(literal != null) {
                 var glyph = buffer.create_tag(null);
                 glyph.weight = 200;

src/lib/NodeActions/CodeBlock.vala

@@ -2,7 +2,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class CodeBlock : Code {
 
-        public CodeBlock(CMark.Node node) {
+        public CodeBlock(NodeInfo node) {
             base(node);
         }
 

src/lib/NodeActions/Embed.vala

@@ -5,7 +5,7 @@ namespace GtkCommonMark.NodeActions {
         private Gtk.Widget widget;
         private Gtk.TextView text_view;
 
-        public Embed(CMark.Node node, Gtk.TextView text_view, Gtk.Widget widget) {
+        public Embed(NodeInfo node, Gtk.TextView text_view, Gtk.Widget widget) {
             base(node);
             this.widget = widget;
             this.text_view = text_view;

src/lib/NodeActions/Emphisis.vala

@@ -2,7 +2,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class Emphisis : SimpleNodeAction {
 
-        public Emphisis(CMark.Node node) {
+        public Emphisis(NodeInfo node) {
             base(node);
         }
 

src/lib/NodeActions/Heading.vala

@@ -4,12 +4,12 @@ namespace GtkCommonMark.NodeActions {
 
     public class Heading : NewlineTerminatedNodeAction {
 
-        public Heading(CMark.Node node) {
+        public Heading(NodeInfo node) {
             base(node);
         }
 
         public override Gtk.TextTag get_tag(TagManager tags) {
-            return tags.get_heading(node.get_heading_level());
+            return tags.get_heading(node.heading_level);
         }
 
     }

src/lib/NodeActions/Item.vala

@@ -6,7 +6,7 @@ namespace GtkCommonMark.NodeActions {
 
         private int level = 0;
 
-        public Item(CMark.Node node) {
+        public Item(NodeInfo node) {
             base(node);
             level = self_nested_count();
         }

src/lib/NodeActions/Link.vala

@@ -2,12 +2,12 @@ namespace GtkCommonMark.NodeActions {
 
     public class Link : SimpleNodeAction {
 
-        public Link(CMark.Node node) {
+        public Link(NodeInfo node) {
             base(node);
         }
 
         public override Gtk.TextTag get_tag(TagManager tags) {
-            return tags.get_link(node.get_url());
+            return tags.get_link(node.url);
         }
 
     }

src/lib/NodeActions/List.vala

@@ -10,10 +10,12 @@ namespace GtkCommonMark.NodeActions {
         private int count = 1;
         private int level = 0;
 
-        public List(CMark.Node node) {
+        public List(NodeInfo node) {
             base(node);
-            numbered = node.get_list_type() == CMark.LIST_TYPE.ORDERED;
-            count = node.get_list_start();
+            numbered = node.list_style == ListStyle.ORDERED;
+            if(numbered) {
+                count = node.list_start_ordinal;
+            }
             level = self_nested_count();
         }
 
@@ -21,7 +23,7 @@ namespace GtkCommonMark.NodeActions {
             return tags.get_list(level);
         }
 
-        public override void at_before_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, CMark.Node child) {
+        public override void at_before_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, NodeInfo child) {
             if(!numbered) {
                 buffer.insert(ref iter, @"$BULLET_CHAR\t", -1);
                 return;

src/lib/NodeActions/NodeAction.vala

@@ -3,10 +3,10 @@ namespace GtkCommonMark.NodeActions {
 
     public abstract class NodeAction : Object {
 
-        public unowned CMark.Node node {get; set;}
+        public NodeInfo node {get; set;}
         public Gtk.TextMark start_mark {get; set;}
 
-        protected NodeAction(CMark.Node node) {
+        protected NodeAction(NodeInfo node) {
             this.node = node;
         }
 
@@ -14,17 +14,17 @@ namespace GtkCommonMark.NodeActions {
         public abstract void at_end(Gtk.TextBuffer buffer, ref Gtk.TextIter iter);
         public abstract void at_after_end(Gtk.TextBuffer buffer, ref Gtk.TextIter iter);
 
-        public abstract void at_before_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, CMark.Node child);
-        public abstract void at_child_start(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, CMark.Node child);
-        public abstract void at_child_end(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, CMark.Node child);
-        public abstract void at_after_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, CMark.Node child);
+        public abstract void at_before_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, NodeInfo child);
+        public abstract void at_child_start(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, NodeInfo child);
+        public abstract void at_child_end(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, NodeInfo child);
+        public abstract void at_after_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, NodeInfo child);
 
         public abstract Gtk.TextTag get_tag(TagManager tags);
 
         protected int self_nested_count() {
-            var type = node.get_type();
+            var type = node.node.get_type();
             var counter = 0;
-            unowned var n = node.parent();
+            unowned var n = node.node.parent();
             while(n != null && n.get_type() != CMark.NODE_TYPE.NONE) {
                 if(n.get_type() == type) {
                     counter++;
@@ -38,7 +38,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class SimpleNodeAction : NodeAction {
 
-        public SimpleNodeAction(CMark.Node node) {
+        public SimpleNodeAction(NodeInfo node) {
             base(node);
         }
 
@@ -51,16 +51,16 @@ namespace GtkCommonMark.NodeActions {
         public override void at_after_end(Gtk.TextBuffer buffer, ref Gtk.TextIter iter) {
             // No-op
         }
-        public override void at_before_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, CMark.Node child) {
+        public override void at_before_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, NodeInfo child) {
             // No-op
         }
-        public override void at_child_start(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, CMark.Node child) {
+        public override void at_child_start(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, NodeInfo child) {
             // No-op
         }
-        public override void at_child_end(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, CMark.Node child) {
+        public override void at_child_end(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, NodeInfo child) {
             // No-op
         }
-        public override void at_after_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, CMark.Node child) {
+        public override void at_after_child(Gtk.TextBuffer buffer, ref Gtk.TextIter iter, NodeInfo child) {
             // No-op
         }
         public override Gtk.TextTag get_tag(TagManager tags) {
@@ -71,7 +71,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class NewlineTerminatedNodeAction : SimpleNodeAction {
 
-        public NewlineTerminatedNodeAction(CMark.Node node) {
+        public NewlineTerminatedNodeAction(NodeInfo node) {
             base(node);
         }
 

src/lib/NodeActions/Paragraph.vala

@@ -2,7 +2,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class Paragraph : SimpleNodeAction {
 
-        public Paragraph(CMark.Node node) {
+        public Paragraph(NodeInfo node) {
             base(node);
         }
 

src/lib/NodeActions/Quote.vala

@@ -2,7 +2,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class Quote : SimpleNodeAction {
 
-        public Quote(CMark.Node node) {
+        public Quote(NodeInfo node) {
             base(node);
         }
 

src/lib/NodeActions/Strong.vala

@@ -2,7 +2,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class Strong : SimpleNodeAction {
 
-        public Strong(CMark.Node node) {
+        public Strong(NodeInfo node) {
             base(node);
         }
 

src/lib/NodeActions/Text.vala

@@ -2,7 +2,7 @@ namespace GtkCommonMark.NodeActions {
 
     public class Text : SimpleNodeAction {
 
-        public Text(CMark.Node node) {
+        public Text(NodeInfo node) {
             base(node);
         }
 
@@ -11,7 +11,7 @@ namespace GtkCommonMark.NodeActions {
         }
 
         public override void at_start(Gtk.TextBuffer buffer, ref Gtk.TextIter iter) {
-            var literal = node.get_literal();
+            var literal = node.literal;
             if(literal != null) {
                 buffer.insert(ref iter, literal, -1);
             }

src/lib/NodeActions/ThematicBreak.vala

@@ -5,7 +5,7 @@ namespace GtkCommonMark.NodeActions {
         private Gtk.TextView text_view;
         private MarkdownViewEmbeddedWidgetHost host;
 
-        public ThematicBreak(CMark.Node node, Gtk.TextView text_view, MarkdownViewEmbeddedWidgetHost host) {
+        public ThematicBreak(NodeInfo node, Gtk.TextView text_view, MarkdownViewEmbeddedWidgetHost host) {
             base(node);
             this.text_view = text_view;
             this.host = host;

src/lib/NodeInfo.vala

@@ -0,0 +1,232 @@
+namespace GtkCommonMark {
+
+    public class NodeInfo {
+
+        internal unowned CMark.Node node {get; set;}
+
+        public NodeType node_type {get; private set;}
+
+        public string url {get; private set;}
+
+        public string title {get; private set;}
+
+        public string literal {get; private set;}
+
+        public ListStyle? list_style {get; private set;}
+
+        public int? list_start_ordinal {get; private set;}
+
+        public int? heading_level {get; private set;}
+
+        public bool is_block { get {
+            switch (node_type) {
+                case NodeType.DOCUMENT:
+                case NodeType.BLOCK_QUOTE:
+                case NodeType.LIST:
+                case NodeType.ITEM:
+                case NodeType.CODE_BLOCK:
+                case NodeType.HTML_BLOCK:
+                case NodeType.CUSTOM_BLOCK:
+                case NodeType.PARAGRAPH:
+                case NodeType.HEADING:
+                case NodeType.THEMATIC_BREAK:
+                    return true;
+                case NodeType.TEXT:
+                case NodeType.SOFTBREAK:
+                case NodeType.LINEBREAK:
+                case NodeType.CODE:
+                case NodeType.HTML_INLINE:
+                case NodeType.CUSTOM_INLINE:
+                case NodeType.EMPH:
+                case NodeType.STRONG:
+                case NodeType.LINK:
+                case NodeType.IMAGE:
+                case NodeType.UNKNOWN:
+                default:
+                    return false;
+            }
+        }}
+
+        public bool is_leaf { get {
+            switch (node_type) {
+                case NodeType.HTML_BLOCK:
+                case NodeType.THEMATIC_BREAK:
+                case NodeType.CODE_BLOCK:
+                case NodeType.TEXT:
+                case NodeType.SOFTBREAK:
+                case NodeType.LINEBREAK:
+                case NodeType.CODE:
+                case NodeType.HTML_INLINE:
+                    return true;
+                case NodeType.DOCUMENT:
+                case NodeType.BLOCK_QUOTE:
+                case NodeType.LIST:
+                case NodeType.ITEM:
+                case NodeType.CUSTOM_BLOCK:
+                case NodeType.PARAGRAPH:
+                case NodeType.HEADING:
+                case NodeType.CUSTOM_INLINE:
+                case NodeType.EMPH:
+                case NodeType.STRONG:
+                case NodeType.LINK:
+                case NodeType.IMAGE:
+                case NodeType.UNKNOWN:
+                default:
+                    return false;
+            }
+        }}
+
+        internal NodeInfo.from_node(CMark.Node node) {
+            this.node = node;
+            var type = node.get_type();
+
+            url = null;
+            title = null;
+            list_start_ordinal = null;
+            heading_level = null;
+            literal = node.get_literal ();
+
+            switch (type) {
+                case CMark.NODE_TYPE.HTML_BLOCK:
+                    node_type = NodeType.HTML_BLOCK;
+                    break;
+
+                case CMark.NODE_TYPE.THEMATIC_BREAK:
+                    node_type = NodeType.THEMATIC_BREAK;
+                    break;
+
+                case CMark.NODE_TYPE.CODE_BLOCK:
+                    node_type = NodeType.CODE_BLOCK;
+                    break;
+
+                case CMark.NODE_TYPE.TEXT:
+                    node_type = NodeType.TEXT;
+                    break;
+
+                case CMark.NODE_TYPE.SOFTBREAK:
+                    node_type = NodeType.SOFTBREAK;
+                    break;
+
+                case CMark.NODE_TYPE.LINEBREAK:
+                    node_type = NodeType.LINEBREAK;
+                    break;
+
+                case CMark.NODE_TYPE.CODE:
+                    node_type = NodeType.CODE;
+                    break;
+
+                case CMark.NODE_TYPE.HTML_INLINE:
+                    node_type = NodeType.HTML_INLINE;
+                    break;
+
+                case CMark.NODE_TYPE.DOCUMENT:
+                    node_type = NodeType.DOCUMENT;
+                    break;
+
+                case CMark.NODE_TYPE.BLOCK_QUOTE:
+                    node_type = NodeType.BLOCK_QUOTE;
+                    break;
+
+                case CMark.NODE_TYPE.LIST:
+                    node_type = NodeType.LIST;
+                    break;
+
+                case CMark.NODE_TYPE.ITEM:
+                    node_type = NodeType.ITEM;
+                    break;
+
+                case CMark.NODE_TYPE.CUSTOM_BLOCK:
+                    node_type = NodeType.CUSTOM_BLOCK;
+                    break;
+
+                case CMark.NODE_TYPE.PARAGRAPH:
+                    node_type = NodeType.PARAGRAPH;
+                    break;
+
+                case CMark.NODE_TYPE.HEADING:
+                    node_type = NodeType.HEADING;
+                    heading_level = node.get_heading_level ();
+                    break;
+
+                case CMark.NODE_TYPE.CUSTOM_INLINE:
+                    node_type = NodeType.CUSTOM_INLINE;
+                    break;
+
+                case CMark.NODE_TYPE.EMPH:
+                    node_type = NodeType.EMPH;
+                    break;
+
+                case CMark.NODE_TYPE.STRONG:
+                    node_type = NodeType.STRONG;
+                    break;
+
+                case CMark.NODE_TYPE.LINK:
+                    node_type = NodeType.LINK;
+                    url = node.get_url ();
+                    title = node.get_title ();
+                    break;
+
+                case CMark.NODE_TYPE.IMAGE:
+                    node_type = NodeType.IMAGE;
+                    url = node.get_url ();
+                    title = node.get_title ();
+                    break;
+
+                default:
+                    node_type = NodeType.UNKNOWN;
+                    break;
+
+            }
+
+            
+            var list_type = node.get_list_type ();
+            switch (list_type) {
+                case CMark.LIST_TYPE.NO_LIST:
+                    list_style = null;
+                    break;
+
+                case CMark.LIST_TYPE.BULLET:
+                    list_style = ListStyle.BULLET;
+                    break;
+
+                case CMark.LIST_TYPE.ORDERED:
+                    list_style = ListStyle.ORDERED;
+                    list_start_ordinal = node.get_list_start ();
+                    break;
+            }
+
+
+        }
+
+    }
+
+    public enum NodeType {
+        UNKNOWN,
+        DOCUMENT,
+        BLOCK_QUOTE,
+        LIST,
+        ITEM,
+        CODE_BLOCK,
+        HTML_BLOCK,
+        CUSTOM_BLOCK,
+        PARAGRAPH,
+        HEADING,
+        THEMATIC_BREAK,
+        TEXT,
+        SOFTBREAK,
+        LINEBREAK,
+        CODE,
+        HTML_INLINE,
+        CUSTOM_INLINE,
+        EMPH,
+        STRONG,
+        LINK,
+        IMAGE
+    }
+
+    public enum ListStyle {
+        BULLET,
+        ORDERED
+    }
+
+}

src/lib/Reader.vala

@@ -12,7 +12,7 @@ namespace GtkCommonMark {
         private Gtk.TextIter tb_iter;
         private List<NodeActions.NodeAction> node_actions;
 
-        public signal void widget_embedded(MarkdownViewEmbeddedWidgetHost widget_host, CMark.Node node);
+        public signal void widget_embedded(MarkdownViewEmbeddedWidgetHost widget_host, NodeInfo node);
 
         public Reader(Gtk.TextBuffer buffer, Gtk.TextView text_view, TagManager tag_manager) {
             this.tags = tag_manager;
@@ -20,7 +20,18 @@ namespace GtkCommonMark {
             this.text_view = text_view;
         }
 
-        public void append_node(CMark.Node root) {
+
+        public void read_file(FileStream stream) {
+            var root = CMark.Node.parse_file (stream, CMark.OPT.DEFAULT);
+            append_node(root);
+        }
+
+        public void read_data(uint8[] document) {
+            var root = CMark.Node.parse_document(document, CMark.OPT.DEFAULT);
+            append_node (root);
+        }
+
+        private void append_node(CMark.Node root) {
             cm_iter = new CMark.Iter(root);
             buffer.get_end_iter(out tb_iter);
             node_actions = new List<NodeActions.NodeAction>();
@@ -34,14 +45,15 @@ namespace GtkCommonMark {
 
                 unowned var node = cm_iter.get_node();
                 
-                var action = build_action_for_node(node);
+                var node_info = new NodeInfo.from_node(node);
+                var action = build_action_for_node(node_info);
 
                 node_actions.prepend(action);
 
                 prepare_for_child();
                 action.at_start(buffer, ref tb_iter);
 
-                if(is_leaf(node.get_type())) {
+                if(node_info.is_leaf) {
                     pop_and_finalise_node_action();
                 }
             }
@@ -81,107 +93,46 @@ namespace GtkCommonMark {
             parent_action.at_after_child(buffer, ref tb_iter, child_action.node);
         }
 
-
-        private bool is_block(CMark.NODE_TYPE type) {
-            switch (type) {
-                case CMark.NODE_TYPE.DOCUMENT:
-                case CMark.NODE_TYPE.BLOCK_QUOTE:
-                case CMark.NODE_TYPE.LIST:
-                case CMark.NODE_TYPE.ITEM:
-                case CMark.NODE_TYPE.CODE_BLOCK:
-                case CMark.NODE_TYPE.HTML_BLOCK:
-                case CMark.NODE_TYPE.CUSTOM_BLOCK:
-                case CMark.NODE_TYPE.PARAGRAPH:
-                case CMark.NODE_TYPE.HEADING:
-                case CMark.NODE_TYPE.THEMATIC_BREAK:
-                    return true;
-                case CMark.NODE_TYPE.TEXT:
-                case CMark.NODE_TYPE.SOFTBREAK:
-                case CMark.NODE_TYPE.LINEBREAK:
-                case CMark.NODE_TYPE.CODE:
-                case CMark.NODE_TYPE.HTML_INLINE:
-                case CMark.NODE_TYPE.CUSTOM_INLINE:
-                case CMark.NODE_TYPE.EMPH:
-                case CMark.NODE_TYPE.STRONG:
-                case CMark.NODE_TYPE.LINK:
-                case CMark.NODE_TYPE.IMAGE:
-                case CMark.NODE_TYPE.NONE:
-                default:
-                    return false;
-            }
-            
-        }
-
-        private bool is_leaf(CMark.NODE_TYPE type) {
-            switch (type) {
-                case CMark.NODE_TYPE.HTML_BLOCK:
-                case CMark.NODE_TYPE.THEMATIC_BREAK:
-                case CMark.NODE_TYPE.CODE_BLOCK:
-                case CMark.NODE_TYPE.TEXT:
-                case CMark.NODE_TYPE.SOFTBREAK:
-                case CMark.NODE_TYPE.LINEBREAK:
-                case CMark.NODE_TYPE.CODE:
-                case CMark.NODE_TYPE.HTML_INLINE:
-                    return true;
-                case CMark.NODE_TYPE.DOCUMENT:
-                case CMark.NODE_TYPE.BLOCK_QUOTE:
-                case CMark.NODE_TYPE.LIST:
-                case CMark.NODE_TYPE.ITEM:
-                case CMark.NODE_TYPE.CUSTOM_BLOCK:
-                case CMark.NODE_TYPE.PARAGRAPH:
-                case CMark.NODE_TYPE.HEADING:
-                case CMark.NODE_TYPE.CUSTOM_INLINE:
-                case CMark.NODE_TYPE.EMPH:
-                case CMark.NODE_TYPE.STRONG:
-                case CMark.NODE_TYPE.LINK:
-                case CMark.NODE_TYPE.IMAGE:
-                case CMark.NODE_TYPE.NONE:
-                default:
-                    return false;
-            }
-            
-        }
-
-        protected virtual NodeActions.NodeAction build_action_for_node(CMark.Node node) {
-            var type = node.get_type();
+        protected virtual NodeActions.NodeAction build_action_for_node(NodeInfo node) {
+            var type = node.node_type;
             switch (type) {
-                case CMark.NODE_TYPE.BLOCK_QUOTE:
+                case NodeType.BLOCK_QUOTE:
                     return build_action_for_block_quote(node);
-                case CMark.NODE_TYPE.LIST:
+                case NodeType.LIST:
                     return build_action_for_list(node);
-                case CMark.NODE_TYPE.ITEM:
+                case NodeType.ITEM:
                     return build_action_for_item(node);
-                case CMark.NODE_TYPE.CODE_BLOCK:
+                case NodeType.CODE_BLOCK:
                     return build_action_for_code_block(node);
-                case CMark.NODE_TYPE.HTML_BLOCK:
+                case NodeType.HTML_BLOCK:
                     return build_action_for_html_block(node);
-                case CMark.NODE_TYPE.CUSTOM_BLOCK:
+                case NodeType.CUSTOM_BLOCK:
                     return build_action_for_custom_block(node);
-                case CMark.NODE_TYPE.PARAGRAPH:
+                case NodeType.PARAGRAPH:
                     return build_action_for_paragraph(node);
-                case CMark.NODE_TYPE.HEADING:
+                case NodeType.HEADING:
                     return build_action_for_heading(node);
-                case CMark.NODE_TYPE.THEMATIC_BREAK:
+                case NodeType.THEMATIC_BREAK:
                     return build_action_for_thematic_break(node);
-                case CMark.NODE_TYPE.TEXT:
+                case NodeType.TEXT:
                     return build_action_for_text(node);
-                case CMark.NODE_TYPE.SOFTBREAK:
+                case NodeType.SOFTBREAK:
                     return build_action_for_soft_break(node);
-                case CMark.NODE_TYPE.LINEBREAK:
+                case NodeType.LINEBREAK:
                     return build_action_for_line_break(node);
-                case CMark.NODE_TYPE.CODE:
+                case NodeType.CODE:
                     return build_action_for_code(node);
-                case CMark.NODE_TYPE.HTML_INLINE:
+                case NodeType.HTML_INLINE:
                     return build_action_for_inline_html(node);
-                case CMark.NODE_TYPE.CUSTOM_INLINE:
+                case NodeType.CUSTOM_INLINE:
                     return build_action_for_inline_custom(node);
-                case CMark.NODE_TYPE.EMPH:
+                case NodeType.EMPH:
                     return build_action_for_emphisis(node);
-                case CMark.NODE_TYPE.STRONG:
+                case NodeType.STRONG:
                     return build_action_for_bold(node);
-                case CMark.NODE_TYPE.LINK:
+                case NodeType.LINK:
                     return build_action_for_link(node);
-                case CMark.NODE_TYPE.IMAGE:
+                case NodeType.IMAGE:
                     return build_action_for_embed(node);
 
                 default:
@@ -190,96 +141,96 @@ namespace GtkCommonMark {
         }
 
 
-        protected virtual NodeActions.NodeAction build_action_for_block_quote(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_block_quote(NodeInfo node) {
             return new NodeActions.Quote(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_list(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_list(NodeInfo node) {
             return new NodeActions.List(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_item(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_item(NodeInfo node) {
             return new NodeActions.Item(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_code_block(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_code_block(NodeInfo node) {
             return new NodeActions.CodeBlock(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_html_block(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_html_block(NodeInfo node) {
             GLib.warning("An HTML block was detected while reading the markdown file which is unsupported, it will be omitted");
             return build_default_action(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_custom_block(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_custom_block(NodeInfo node) {
             GLib.warning("A custom block was detected while reading the markdown file which is unsupported, it will be omitted");
             return build_default_action(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_paragraph(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_paragraph(NodeInfo node) {
             return new NodeActions.Paragraph(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_heading(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_heading(NodeInfo node) {
             return new NodeActions.Heading(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_thematic_break(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_thematic_break(NodeInfo node) {
             var host = build_embed_widget(node);
             return new NodeActions.ThematicBreak(node, text_view, host);
         }
 
         // Inline Elements
-        protected virtual NodeActions.NodeAction build_action_for_text(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_text(NodeInfo node) {
             return new NodeActions.Text(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_soft_break(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_soft_break(NodeInfo node) {
             return build_default_action(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_line_break(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_line_break(NodeInfo node) {
             return new NodeActions.Break(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_code(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_code(NodeInfo node) {
             return new NodeActions.Code(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_inline_html(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_inline_html(NodeInfo node) {
             GLib.warning("An HTML inline segment was detected while reading the markdown file which is unsupported, it will be omitted");
             return build_default_action(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_inline_custom(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_inline_custom(NodeInfo node) {
             GLib.warning("A custom inline segment was detected while reading the markdown file which is unsupported, it will be omitted");
             return build_default_action(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_emphisis(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_emphisis(NodeInfo node) {
             return new NodeActions.Emphisis(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_bold(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_bold(NodeInfo node) {
             return new NodeActions.Strong(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_link(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_link(NodeInfo node) {
             return new NodeActions.Link(node);
         }
 
-        protected virtual NodeActions.NodeAction build_action_for_embed(CMark.Node node) {
+        protected virtual NodeActions.NodeAction build_action_for_embed(NodeInfo node) {
             return new NodeActions.Embed(node, text_view, build_embed_widget(node));
         }
 
-        protected virtual NodeActions.NodeAction build_default_action(CMark.Node node) {
-            if(is_block(node.get_type())) {
+        protected virtual NodeActions.NodeAction build_default_action(NodeInfo node) {
+            if(node.is_block) {
                 return new NodeActions.NewlineTerminatedNodeAction(node);
             }
             return new NodeActions.SimpleNodeAction(node);
         }
 
-        protected virtual MarkdownViewEmbeddedWidgetHost build_embed_widget(CMark.Node node) {
+        protected virtual MarkdownViewEmbeddedWidgetHost build_embed_widget(NodeInfo node) {
             var widget = new MarkdownViewEmbeddedWidgetHost();
             widget_embedded(widget, node);
             widget.show();

src/lib/meson.build

@@ -15,6 +15,7 @@ dependencies = [
 sources = files('Reader.vala')
 sources += files('TagManager.vala')
 sources += files('MarkdownView.vala')
+sources += files('NodeInfo.vala')
 sources += files('EmbeddedWidgetLayoutManager.vala')
 sources += files('NodeActions/NodeAction.vala')
 sources += files('NodeActions/Heading.vala')
@@ -43,7 +44,7 @@ libgtkcmark_dep = declare_dependency(link_with: libgtkcmark, include_directories
 pkg = import('pkgconfig')
 pkg.generate(libgtkcmark,
     version : '0.1',
-    name : 'libgtkcommonmark',)
+    name : 'gtkcommonmark',)
     
 g_ir_compiler = find_program('g-ir-compiler')
 custom_target('gtkcommonmark typelib', command: [g_ir_compiler, '--shared-library=libgtkcommonmark.so', '--output', '@OUTPUT@', meson.current_build_dir() / 'GtkCommonMark-1.0.gir'],

src/viewer/Main.vala

@@ -18,8 +18,8 @@ int main (string[] argv) {
             text_view.set_wrap_mode (WrapMode.WORD_CHAR);
     
             text_view.link_activated.connect (url => print(@"Url clicked: $url\n"));
-            text_view.widget_embedded.connect ((w, n) => {
-                var url = Path.build_filename (file.get_parent().get_path(), n.get_url ());
+            text_view.widget_embedded.connect ((w, fname, title) => {
+                var url = Path.build_filename (file.get_parent().get_path(), fname);
                 print(@"Load image: $url\n");
                 var image = new Gtk.Picture.for_filename (url);
                 image.content_fit = Gtk.ContentFit.FILL;