FastLBRY-GTK/flbry/markdown.py

#####################################################################
#                                                                   #
#  THIS IS A SOURCE CODE FILE FROM A PROGRAM TO INTERACT WITH THE   #
# LBRY PROTOCOL ( lbry.com ). IT WILL USE THE LBRY SDK ( lbrynet )  #
# FROM THEIR REPOSITORY ( https://github.com/lbryio/lbry-sdk )      #
# WHICH I GONNA PRESENT TO YOU AS A BINARY. SINCE I DID NOT DEVELOP #
# IT AND I'M LAZY TO INTEGRATE IN A MORE SMART WAY. THE SOURCE CODE #
# OF THE SDK IS AVAILABLE IN THE REPOSITORY MENTIONED ABOVE.        #
#                                                                   #
#      ALL THE CODE IN THIS REPOSITORY INCLUDING THIS FILE IS       #
# (C) J.Y.Amihud and Other Contributors 2021. EXCEPT THE LBRY SDK.  #
# YOU CAN USE THIS FILE AND ANY OTHER FILE IN THIS REPOSITORY UNDER #
# THE TERMS OF GNU GENERAL PUBLIC LICENSE VERSION 3 OR ANY LATER    #
# VERSION. TO FIND THE FULL TEXT OF THE LICENSE GO TO THE GNU.ORG   #
# WEBSITE AT ( https://www.gnu.org/licenses/gpl-3.0.html ).         #
#                                                                   #
# THE LBRY SDK IS UNFORTUNATELY UNDER THE MIT LICENSE. IF YOU ARE   #
# NOT INTENDING TO USE MY CODE AND JUST THE SDK. YOU CAN FIND IT ON #
# THEIR OFFICIAL REPOSITORY ABOVE. THEIR LICENSE CHOICE DOES NOT    #
# SPREAD ONTO THIS PROJECT. DON'T GET A FALSE ASSUMPTION THAT SINCE #
# THEY USE A PUSH-OVER LICENSE, I GONNA DO THE SAME. I'M NOT.       #
#                                                                   #
# THE LICENSE CHOSEN FOR THIS PROJECT WILL PROTECT THE 4 ESSENTIAL  #
# FREEDOMS OF THE USER FURTHER, BY NOT ALLOWING ANY WHO TO CHANGE   #
# THE LICENSE AT WILL. SO NO PROPRIETARY SOFTWARE DEVELOPER COULD   #
# TAKE THIS CODE AND MAKE THEIR USER-SUBJUGATING SOFTWARE FROM IT.  #
#                                                                   #
#####################################################################

import os
from subprocess import *
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import Pango


from flbry import ui

################################################################################

# Markdown. Or .md file format is an easy way to give your simple text documents
# a bit of flare. Stuff like links, images and quotes are supported. Also bold
# an italic characters.



def Open(md):


    # Spliting it for the read.
    md = "\n\n"+md
    md = md.split("\n")
    
    # First thing is I was to read the headings and convert it into a tree.
    
    
    tree = []
    indent = 1
    c = []

    skip = 0
    
    for n,line in enumerate(md):

        if skip > n:
            continue
    
        ty = "text"
        te = line
        
        # Here I want to simply get a type of each line. Later we going to parse
        # the links and other things. But first. Let's parse stuff based on
        # lines.

        if line.startswith("```"):

            # THREE ``` aka code block

            # This tag will block any other tags
            # untill it's untagged

            code = ""
            for l in md[n+1:]:
                if not l.startswith("```"):
                    code = code + l + "\n"
                    
                else:
                    skip = n + code.count("\n") + 2
                    break
            
            tree.append(["text_cm", code+"\n"])
            te = ""
            
        elif line.startswith("#"):
            # The titles of the chapter. The Headers are usually written similar
            # to how here in python you write comments. It's a # , space, and the
            # text.
            
            # The amount of hashes. ## or ### gives different sized text. Officialy
            # it should support up to 6 hashes. ######. But why not make it more
            # just in case.
            
            ty = line.count("#") # This might give bugs
        
        elif line.startswith(">"):
            
            # The > sign in the Markdown language is used for quatations. 
            
            ty = "text_q"
            te = te[1:]
            
        tree.append([ty, te+"\n"])        
        
    # Now the stage 0 is over and we parsed the basic things. Now is the hard
    # part to parse out all the images and stuff inside them. It's going to be
    # done per part. And we are going to use the same technique I used for the
    # conversion of the legacy projects. See : studio/story.py ( in VCStudio )
    
    # We are going to itterate over each letter. And decide what to do by that
    
    newtree = []
    
    for block in tree:

        if block[0] == "text_cm":
            newtree.append(block)
            continue
        
        part = ""
        skip = 0
        
        for n, l in enumerate(block[-1]):
            
            if skip > n:
                continue
            
            part = part + l
            
            # Here we are going to do something if a give condition is met.
            # Usually I gonna do something if [part] ends with a given markdown
            # thing. I don't have a manual of markdown on me. So please make it
            # more supported. I guess. I might forget things I rarely use.
            
            # Links are made with [stuff you click on](https://example.com)
            # but similar to it. Images are done ![Tooltip](Image.png)
            # and even weirder you can put one into the other. Like
            # [![Tooltip](Image.png)](https://example.com)
            # Which going to give you a clickable image.
            
            # For this version what we are going to do is next. 
            # If we got [![ then it's a clickable image
            # If we got ![ then it's just image
            # and if we got [ then it's a link.
        
            if part.endswith("[!["):
                
                # IMAGE LINK
                newtree.append([block[0], part[:-3]])

                tooltip = ""
                imageurl = ""
                url = ""
                t = False
                iu = False
                skip = n
                for le in block[-1][n:]: # For letters in the rest of text

                    skip = skip + 1

                    if le == "]":
                        t = True
                    elif le == ")" and t and not iu:
                        iu = True
                    elif le == ")" and t and iu:
                        break
                    elif not t:
                        tooltip = tooltip +le
                    elif t and not iu:
                        imageurl = imageurl + le
                    else:
                        url = url+le

                tooltip = tooltip[tooltip.find("[")+1:]
                imageurl = imageurl[imageurl.find("(")+1:]
                url = url[url.find("(")+1:]
                
                apnd = ["image_link", imageurl, url]
                
                newtree.append(apnd)

                part = ""
                
            
            elif part.endswith("!["):
                
                # IMAGE

                newtree.append([block[0], part[:-2]])
                
                tooltip = ""
                url = ""
                t = False
                skip = n
                for le in block[-1][n:]: # For letters in the rest of text

                    skip = skip + 1

                    if le == "]":
                        t = True
                    elif le == ")" and t:
                        break
                    elif not t:
                        tooltip = tooltip +le
                    else:
                        url = url+le

                tooltip = tooltip[tooltip.find("[")+1:]
                url = url[url.find("(")+1:]

                apnd = ["image", "[IMAGE]", url]
                newtree.append(apnd)
                
                part = ""
                
            
            elif part.endswith("[") and not block[-1][n:].startswith('[!['):
                
                # LINK
                newtree.append([block[0], part[:-1]])
                
                
                tooltip = ""
                url = ""
                t = False
                skip = n
                for le in block[-1][n:]: # For letters in the rest of text

                    skip = skip + 1

                    if le == "]":
                        t = True
                    elif le == ")" and t:
                        break
                    elif not t:
                        tooltip = tooltip +le
                    else:
                        url = url+le

                tooltip = tooltip[tooltip.find("[")+1:]
                url = url[url.find("(")+1:]
                    
                apnd = ["link", tooltip, url]
                newtree.append(apnd)
                
                part = ""
                
                
                
            # Now I want to deal with `, *, ** and ***. If you want to help me you
            # can implement other types. Such as _, __, ___ and so on. Markdown is
            # a very rich language. I'm going to use the cut down version I see other
            # people use.

            # BTW this is the time. Feb 28. When I switched from Gedit to GNU Emacs.
            # Interesting feeling using this programm. I kind a love it even tho
            # so many stuff in not intuitive. Like saving is not Ctrl - S but
            # Ctrl - X -> Ctrl - S.

            # Things like Alt-; to comment multiple lines at ones is HUGE. Also it
            # was built by programmers for programmers. So it's a very good tool.

            elif part.endswith("**") and not block[-1][n+2:].startswith('*'):
                
                # DOUBLE **
                
                newtree.append([block[0], part[:-2]])

                if block[0] == "text":
                    block[0] = "text_b"
                else:
                    block[0] = "text"

                part = ""
            
            elif part.endswith("*") and not block[-1][n+1:].startswith('*'):
                
                # SINGLE *
                
                newtree.append([block[0], part[:-1]])

                if block[0] == "text":
                    block[0] = "text_i"
                else:
                    block[0] = "text"

                part = ""


            elif part.endswith("`"):
                
                # SINGLE `
                
                newtree.append([block[0], part[:-1]])

                if block[0] == "text":
                    block[0] = "text_c"
                else:
                    block[0] = "text"

                part = ""
            
        newtree.append([block[0], part])
        
        
    #newtree.append(["text", "\n"*20+" [END OF DOCUMENT] "])
    tree = newtree
        
    return(tree)

def search_convert(s):

    # This function convers a chapter name into a link
    # such links are use in notabug.org to link to chapters
    # for example example.com/file.md#chapter-name
    # With this url it will load the example.com/file.md and
    # then skip to the "Chapter Name" chapter.

    # This function transforms "Chapter Name" into "chapter-name"
    
    l = " ./\|[]{}()?!@#$%^&*`~:;'\"=,<>"
    s = s.lower().replace(" ","-")
    r = ""
    for i in s:
        if i not in l:
            r = r + i
    return r

def convert(win, text_view):

    text_buffer = text_view.get_buffer()
    st = text_buffer.get_start_iter()
    en = text_buffer.get_end_iter()
    text = text_buffer.get_text(st, en, True)
    text_buffer.set_text("")

    text_buffer.create_tag("text", justification=Gtk.Justification.FILL, left_margin=64, right_margin=64)
    text_buffer.create_tag("text_c", background="#eeeeee", foreground="#000000", font="Monospace", left_margin=64, right_margin=64)
    text_buffer.create_tag("text_b", font="Bold", justification=Gtk.Justification.FILL, left_margin=64, right_margin=64)
    text_buffer.create_tag("text_i", font="Italic", justification=Gtk.Justification.FILL, left_margin=64, right_margin=64)
    text_buffer.create_tag("text_q", justification=Gtk.Justification.FILL, left_margin=200, right_margin=200)
    text_buffer.create_tag("header", size_points=30, justification=Gtk.Justification.CENTER, left_margin=64, right_margin=64)
    text_view.set_justification(Gtk.Justification.CENTER)
    
    md = Open(text)
    markup = ""
    
    for i in md:
        
        en = text_buffer.get_end_iter()

        
        
        if type(i[0]) == str and i[0].startswith("text") and not i[0] == "text_cm":
            try:
                text_buffer.insert_with_tags_by_name(en, i[-1], i[0])
            except:
                text_buffer.insert(en, i[-1])

        elif i[0] == "text_cm":
            codeview = Gtk.TextView()
            #codeview.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(0.2,0.2,0.2, 1))
            #codeview.override_color(Gtk.StateType.NORMAL, Gdk.RGBA(0.9,0.9,0.9, 1))
            codeview.override_font(Pango.FontDescription("Monospace"))
            codescrl = Gtk.ScrolledWindow()
            codescrl.set_size_request(900, 500)
            codeview.set_editable(True)
            codescrl.add(codeview)
            codebuffer = codeview.get_buffer()
            codebuffer.set_text(i[-1])
            anchor = Gtk.TextChildAnchor()
            text_buffer.insert_child_anchor(en, anchor)
            text_view.add_child_at_anchor(codescrl , anchor)
                
        elif type(i[0]) == int:
            text_buffer.insert_with_tags_by_name(en, i[-1].replace("#", ""), "header")

        elif i[0] == "image_link":
            image = ui.load(win, ui.net_image_calculation, ui.net_image_render, i[1], 800, "", True)

            
            def link_launch(w, link):
                os.system("xdg-open "+link)
            def link_resolve(w, link):
                win.url.set_text(link)
                win.url.activate()

            optionsthing = Gtk.Popover()
            optbox = Gtk.VBox()
            optionsthing.add(optbox)
            opt_launch = Gtk.Button("Launch")
            optbox.pack_start(opt_launch, False, False, False)
            opt_resolve = Gtk.Button("Resolve")
            optbox.pack_start(opt_resolve, False, False, False)
            opt_launch.connect("clicked", link_launch, i[-1])
            opt_resolve.connect("clicked", link_resolve, i[-1])
            optbox.show_all()

            
            link = Gtk.MenuButton(popover=optionsthing)
            link.add(image)
            anchor = Gtk.TextChildAnchor()
            text_buffer.insert_child_anchor(en, anchor)
            text_view.add_child_at_anchor(link, anchor)

                
        elif i[0] == "image":
            image = ui.load(win, ui.net_image_calculation, ui.net_image_render, i[-1], 800, "", True)
            anchor = Gtk.TextChildAnchor()
            text_buffer.insert_child_anchor(en, anchor)
            text_view.add_child_at_anchor(image , anchor)

        elif i[0] == "link":

            # link = Gtk.LinkButton.new_with_label(
            #     uri=i[-1],
            #     label=i[1])
            def link_launch(w, link):
                os.system("xdg-open "+link)
            def link_resolve(w, link):
                win.url.set_text(link)
                win.url.activate()

            optionsthing = Gtk.Popover()
            optbox = Gtk.VBox()
            optionsthing.add(optbox)
            opt_launch = Gtk.Button("Launch")
            optbox.pack_start(opt_launch, False, False, False)
            opt_resolve = Gtk.Button("Resolve")
            optbox.pack_start(opt_resolve, False, False, False)
            opt_launch.connect("clicked", link_launch, i[-1])
            opt_resolve.connect("clicked", link_resolve, i[-1])
            optbox.show_all()
            
            link = Gtk.MenuButton(label=i[1], popover=optionsthing)

            link.set_tooltip_text(i[-1])
            anchor = Gtk.TextChildAnchor()
            text_buffer.insert_child_anchor(en, anchor)
            text_view.add_child_at_anchor(link, anchor)