VCStudio/UI/UI_elements.py

# THIS FILE IS A PART OF VCStudio
# PYTHON 3

# This a console project manager.

import os
import math
import urllib3
import hashlib
import threading

# GTK module ( Graphical interface
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import GLib
from gi.repository import GdkPixbuf
import cairo

# Own modules
from settings import settings
from settings import talk
from settings import fileformats

# UI
from UI import UI_color

def roundrect(layer, win, x, y, width, height, r, button=False, icon=False, 
              tip="", fill=True, url="", clip=False, offset=[0,0], text=False):
    
    # This function draws a rectangle with rounded edges.
    
    # A button variable is a calable for the button action. Basically it's a
    # function. Roundrect will act as a button.
    if button:
        
        #if not current url in the software
        if url and url != win.url:
            
            # So icons would not disappear LOL
            if icon:
                image(layer, win, "settings/themes/"\
                +win.settings["Theme"]+"/icons/"+icon+".png", x, y)
            
            return
        
        # If UI testing is on preview. Buttons.
        if win.current["testing"]:
            UI_color.set(layer, win, "testing_banner")
            layer.rectangle(x,y,width,height)
            layer.stroke()
        
        
        if  win.current['mx'] in range(int(x+offset[0]), int(x+width+offset[0])) \
        and win.current['my'] in range(int(y+offset[1]), int(y+height+offset[1])) :
            do = True
            
            if clip:
                if  win.current['mx'] in range(int(clip[0]), int(clip[0]+clip[2])) \
                and win.current['my'] in range(int(clip[1]), int(clip[1]+clip[3])) :
                    do = True
                else:
                    do = False
        
        else:
            do = False
        
        
            
        if do:
        
            # cursor
            if text:
                win.current["cursor"] = win.cursors["text"]
            else:
                win.current["cursor"] = win.cursors["hand"]
            
            # If holding click
            if win.current["LMB"]:
                UI_color.set(layer, win, "button_clicked")
            else:
                UI_color.set(layer, win, "button_active")
            # If clicked
            if win.previous["LMB"] and not win.current["LMB"]:
                win.current["cursor"] = win.cursors["watch"]
                button()
            
            # Button might have a tooltip as well
            if tip:
                tooltip(win, tip)
        
        
    else:
        do = True
    
    if do:
        # Making sure that round rectangle will not be smaller then it's round-
        # ness. Also with width and height zero, it's going to draw a circle.
        
        if width < r*2:
            width = r*2
        if height < r*2:
            height = r*2
        
        # I just out of blue decided that I want to have a setting to restrict
        # the amount of roundness for every roundrect. If the user want let him
        # or her have ugly squares everywhere.
        
        if "Roundness" not in win.settings:
            win.settings["Roundness"] = 1.0
            settings.write("Roundness", 1.0)
        
        r = r*win.settings["Roundness"]
        
        # actuall drawing
        layer.move_to(x,y+r)
        layer.arc(x+r, y+r, r, math.pi, 3*math.pi/2)
        layer.arc(x+width-r, y+r, r, 3*math.pi/2, 0)
        layer.arc(x+width-r, y+height-r, r, 0, math.pi/2)
        layer.arc(x+r, y+height-r, r, math.pi/2, math.pi)
        layer.close_path()
        if fill:
            layer.fill()
    
    # Icon is a continuation of the button part. Because you need a way to see
    # that that the button is even there to begin with.
    if icon:
        image(layer, win, "settings/themes/"\
        +win.settings["Theme"]+"/icons/"+icon+".png", x, y)
    
def animate(name, win, v1=0, v2=None, time=10, force=False):
    
    # This function will make animating values over time possible. For smooth
    # Transisions and things like this it's going to be very usefull.
    
    
    
    # Let's clear mess in case they I'm lazy to make all the things
    if v2 == None:
        v2 = v1
        
    # Set up the animation into the animations. If it's not there yet.
    if name not in win.animations or force:
        win.animations[name] = [
            v1,
            v2,
            time,
            win.current["frame"]
            ]
   
    # Let's get data out of the win.animation[name]
    v1    = win.animations[name][0]
    v2    = win.animations[name][1]
    time  = win.animations[name][2]
    start = win.animations[name][3]
    frame = win.current["frame"]
    
    if time == 0:
        return v2
    
    # If animation is over.
    if start + time < frame:
        return v2
    
    # If v1 and v2 are the same. I'm doing it here. In case the value would be
    # Animated later. So it will create the animation instance.
    if v1 == v2:
        return v2
    
    if v1 < v2:
        vN = v1 + ((v2 - v1)/time*(frame-start))
    else:
        vN = v1 - ((v1 - v2)/time*(frame-start))
    
    return vN    
    
def blur(surface, win, amount):
    
    # This function will blur a given layer by scaling it down and scaling it 
    # back up. It will be doing it only when a given blur setting it active.
    
    # To avoid all kinds of Zero devision problems. And speed up the draw if
    # using animated blur values.
    if amount < 3: # When Blue value was less then 3 it felt sharp but not enough
        return surface # Which caused sense of uneasiness. 
    
    # Setting up initial Blur
    if not "Blur" in win.settings:
        settings.write("Blur", True)       # Writing to file
        win.settings = settings.load_all() # Loading file back to RAM
    
    # If to active blur. Will be changed in the graphics settings. 
    if win.settings["Blur"]:
        # scaling down
        surface1 = cairo.ImageSurface(cairo.FORMAT_ARGB32, win.current['w'],
                                                           win.current['h'])

        

        slacedownlayer = cairo.Context(surface1)
        slacedownlayer.scale(1/amount, 
                             1/amount)
        
        slacedownlayer.set_source_surface(surface, 0 , 0)
        slacedownlayer.paint()
        
        #scaling back up
        surface2 = cairo.ImageSurface(cairo.FORMAT_ARGB32, win.current['w'],
                                                           win.current['h'])
        slaceuplayer = cairo.Context(surface2)
        
        slaceuplayer.scale(amount, 
                           amount)

        
        
        slaceuplayer.set_source_surface(surface1, 0 , 0)
        
        # Pixelized Blur
        if not "PixelBlur" in win.settings:
            settings.write("PixelBlur", False)       # Writing to file
            win.settings = settings.load_all()
        if win.settings["PixelBlur"]:
            p = slaceuplayer.get_source()
            p.set_filter(cairo.FILTER_NEAREST)

        slaceuplayer.paint()
        
        return surface2
    else:
        return surface

def hash_file(f):
    
    # This function will give me MD5 hashes of various files
    
    try:
        BLOCKSIZE = 65536
        hasher = hashlib.md5()
        with open(f, 'rb') as afile:
            buf = afile.read(BLOCKSIZE)
            while len(buf) > 0:
                hasher.update(buf)
                buf = afile.read(BLOCKSIZE)
        return str(hasher.hexdigest())
    except:
        return "FOLDER"

def loadimage(layer, win ,path, x, y, width, height, fit, cell=0):

    # Before we load an image we have to know whether the image is local
    # in the Internet. Markdown files for example can have links to a
    # picture in the internet. And so if a given Image URL is not local
    # we have to be able to download it.

    # For reasons we all can relate to. I don't want such downloading to
    # happen automatically. Unless the user is going to enable auto
    # download in the settings.

    # Let's set up a setting. I'm doing it here because Images drawn
    # first. On the main screen. And the setting does not exists in
    # the earlier settings file from the earlier version.

    if "auto_download_images" not in win.settings:
        win.settings["auto_download_images"] = False
        settings.write("auto_download_images", win.settings["auto_download_images"])
        
    filename = "/tmp/"+path.replace("/","_")
    # It could an image data without an image .png thing
    found = False
    for f in fileformats.images:
        if filename.endswith(f):
           found = True
    if not found:
        filename = filename+".png"

    tmppath = ""

    if path.startswith("http") and not os.path.exists(filename):

            
        if win.images[cell][path]["image"]  != "downloading":

            # If the button is not pressed yet. Then we need to
            # put a downlod button. Look down where implement
            # the drawing of the image for the button it self.
            
            win.images[cell][path]["loading"] = False
            win.images[cell][path]["image"]   = "download_button"
            return

        else:
            
            # Now somebody either pressed the button. Or it set to
            # automatic downloads. Then, let's get the file.

            win.images[cell][path]["image"]   = None
            
            http = urllib3.PoolManager()
            r = http.request('GET', path, preload_content=False)
            with open(filename, 'wb') as out:
                while True:
                    data = r.read(1024)
                    if not data:
                        break
                    out.write(data)

            r.release_conn()
            

    elif path.startswith("http"):
        tmppath = path
        path = filename

        
           
    # Also I don't want downloading to happen here. Since if it's not
    # downloaded 
    
    # So multiple types of the image could be loaded. It could be either
    # an image file. Like png or jpeg. Either a video file. Or a blend file
    # each with it's own loading problems. 
        
    # While cairo can read pngs directly. It's not the best way of doing it
    # since it's not capable of reading jpegs and other files. So let's do
    # something about it.
    
    foundformat = False
    
    # IMAGEFILES
    for f in fileformats.images:
        if path.endswith(f):
            
            foundformat = True
            
            # So this parth of the code is for loading all simple images. From
            # pngs Jpegs to anything else.
            
            # We are going to use Gtk's GdkPixbuf for this. We will need to 
            # convert it to cairo surface later
            
            try:
                load1 = GdkPixbuf.Pixbuf.new_from_file(path)
            except:
                
                try:
                    load1 = GdkPixbuf.Pixbuf.new_from_file("settings/themes/"+win.settings["Theme"]+"/icons/image.png")
                except:
                    load1 = GdkPixbuf.Pixbuf.new_from_file("settings/themes/Default/icons/image.png")
                
    # VIDEOFILES
    for f in fileformats.videos:
        if path.endswith(f):
            
            foundformat = True
            
            # Now if it's a video. It's going to be a little harder. We will need
            # to use totem. It's a video player that exists in many GNU/Linux 
            # systems. Unfortunatly not everybody could see video previews.
            
            try:
                
                # This is going to require a few steps.
                
                # 1. Making a filename for our totem to output. 
                part = path.replace("/", "_").replace(" ", "_")
                
                # 2. Calling totem. And telling him that we want a thumbnail. 
                os.system("totem-video-thumbnailer -s "+str(width)+" "+path\
                                +" /tmp/vcstudio_thumbnail"+part+".png")
                
                # 3. Loading this thumbnail.
                load1 = GdkPixbuf.Pixbuf.new_from_file("/tmp/vcstudio_thumbnail"+part+".png")
                
                # 4. Cleaning the thumbnail from the OS.
                try:
                    os.remove("/tmp/vcstudio_thumbnail"+part+".png")
                except:
                    pass
                
            except:
                try:
                    load1 = GdkPixbuf.Pixbuf.new_from_file("settings/themes/"+win.settings["Theme"]+"/icons/video.png")
                except:
                    load1 = GdkPixbuf.Pixbuf.new_from_file("settings/themes/Default/icons/video.png")
    # BLEND FILES
    
    for f in ["blend", "blend1"]:
        if path.endswith(f):
            
            foundformat = True
            
            # Similarly to the Video. Blends files has their own thumbnailer. This
            # time it's inside of the code of VCStudio. But I've copied it from
            # the blender's installation folder. So you can find it there too
            # it's called blender-thumbnailer.py. Which is a python script. Which
            # is cool.
            
            # Because thumbnailer is developed to work regardless of whether blender
            # is installed or not. As it's reading the blend file directly. And
            # not using some bpy script. We can copy that over to VCStudio and use
            # it to give previews to users who do not have blender installed.
            
            try:
                
                # This is going to require a few steps.
                
                # 1. Making a filename for our thumbnailer to output. 
                part = path.replace("/", "_").replace(" ", "_")
                
                # 2. Calling thumbnailer. And telling him that we want a thumbnail. 
                os.system("python3 "+os.getcwd()+"/UI/blender-thumbnailer.py "\
                            +path+" /tmp/vcstudio_thumbnail"+part+".png")
                
                # 3. Loading this thumbnail.
                load1 = GdkPixbuf.Pixbuf.new_from_file("/tmp/vcstudio_thumbnail"+part+".png")
                
                # 4. Cleaning the thumbnail from the OS.
                try:
                    os.remove("/tmp/vcstudio_thumbnail"+part+".png")
                except:
                    pass
                
            except:
                
                try:
                    load1 = GdkPixbuf.Pixbuf.new_from_file("settings/themes/"+win.settings["Theme"]+"/icons/blender.png")
                except:
                    load1 = GdkPixbuf.Pixbuf.new_from_file("settings/themes/Default/icons/blender.png")
     
    if not foundformat:
        
        # If you can't find any format. Just use the file icon then
        try:
            load1 = GdkPixbuf.Pixbuf.new_from_file("settings/themes/"+win.settings["Theme"]+"/icons/file.png")
        except:
            load1 = GdkPixbuf.Pixbuf.new_from_file("settings/themes/Default/icons/file.png")

        
        
    # Then to convert the pixbuf to a cairo surface
    Px = load1.get_width()
    Py = load1.get_height()
    load2 = cairo.ImageSurface(cairo.FORMAT_ARGB32, Px, Py)
    imagedraw = cairo.Context(load2)
    Gdk.cairo_set_source_pixbuf( imagedraw, load1, 0, 0)
    imagedraw.paint()
    
    # If I want to resize the image for an icon or something. There is            
    # gonna be the folowing algorythm.
    
    if width or height:
        
        dx = 0
        dy = 0
        
        
        imagesurface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
        imagedraw = cairo.Context(imagesurface)
        
        # Crop effect. Really hard on my brains.
        
        if fit == 'crop':
            if height > load2.get_height()\
            or width  > load2.get_width():
                
                dx = (width/2) -(load2.get_width() /2)
                dy = (height/2)-(load2.get_height()/2)
                
            else:
                factor = 1
                if (load2.get_height()*(width/load2.get_width()))\
                    < height:
                    factor = height / load2.get_height()
                else:
                    factor = width / load2.get_width()
                #factor = 0.1
                imagedraw.scale(factor, factor)    
                dx = (width/2)/factor -(load2.get_width() /2)
                dy = (height/2)/factor -(load2.get_height()/2)

        # Finally I need to implement something but the Crop.
        # Fit Width I want to use in MarkDowns. Maybe also in the
        # text of the script. Makes sense.
        
        elif fit == "fit_width" and load2.get_width() > width:
            factor = width / load2.get_width()
            dx = 0
            dy = 0
            imagesurface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(width), int(load2.get_height()*factor))
            imagedraw = cairo.Context(imagesurface)
            imagedraw.scale(factor, factor)
        elif fit == "fit_width":
            dx = 0
            dy = 0
            imagesurface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(load2.get_width()), int(load2.get_height()))
            imagedraw = cairo.Context(imagesurface)
            
            
        # Let's make an ability for theme makers to simply color the standard
        # icons into any shade.
                
        imagedraw.set_source_surface(load2, dx, dy)    
        imagedraw.paint()  
    else:
        imagesurface = load2
        
    # Saving it into the win.images
    if tmppath:
        path = tmppath
    win.images[cell][path]["loading"] = False
    win.images[cell][path]["image"]   = imagesurface
    win.images[cell][path]["hash"]    = hash_file(path)
    
    win.imageload -= 1

def reload_images(win):
    
    # This function will force the images to refrash. For things like sync
    # or simply where a file is changed. Or for any other reason. Now we 
    # probably don't need to do this on every image. So instead we are going
    # to compare the hashes of the current images to the ones of the files
    # and if they changed. We are going to update those.
    
    for cell in list(win.images.keys()):
        for image in list(win.images[cell].keys()):
            if hash_file(image) != win.images[cell][image]["hash"]:
                win.images[cell][image]["loading"] = True
    
    pass

def image(layer, win ,path, x, y, width=0, height=0, fit="crop", cell=0, offset=[0,0]):
    
    # This module will handle drawing images to the layers. It's not that hard
    # to do in cairo by default. But i'm doing it at every frame. And so it
    # means a system of images should exist to take out the load. Basically
    # it will make sure the images is loaded only ones. And for the next draw
    # calls it will forward the old image.
    
    # Attempt of optimization. Keeping in mind the nature of the programm. Basi-
    # cally I will not load image unless x and y are in frame. Kind a ugly. I
    # know. But I don't want to even bother checking the resolution of the image
    # if it's not in a frame. Roughly speaking. Will see maybe I will make do
    # something to make it better.
    
    if cell not in win.images:
        win.images[cell] = {}
    
    if int(x) not in range(int(0-width ), int(win.current["w"])) or \
       int(y) not in range(int(0-height-win.current["h"]), int(win.current["h"])) :
        return
    
    # If you ran this software you probably noticed that images are loading
    # dynamically. I did it using this following crazy algorythm borowed from
    # the old organizer. 
    
    # Here I want to load images. But I also want to give myself an ability to
    # load refrash images. Without refrashing all the images. For this I'm going
    # to use hashes. Specificly MD5 but it doesn't matter really. The idea is
    # that on a special redraw call. We are going to check hashes storred with 
    # those from the file. And only if a file really changed. Then update the image.
    
    
    # First the icon might not exist in the icon pack. Since I want to make 
    # packs using
    if win.settings["Theme"] in path and not os.path.exists(path):
        path = path.replace(win.settings["Theme"], "Default")
    
    if path not in win.images[cell] or win.images[cell][path]["loading"]: 
        
        # If this is the first time this image is draw we want to create it a data
        # structure. So we could load the image.
        
        win.images[cell][path] = {
            "loading": True, # Whether the image is currently loading.
            "image"  : None, # The image data it self.
            "hash"   : ""    # The hash of the image file.
            }
            
        # Then we want to insure to load only a given amount of images in the same
        # time. For this we are going to use the next variable.
        
        MAXLOAD = 10
        
        if win.imageload < MAXLOAD:
            win.imageload += 1
        
        
            # Now we want to load the image. But we are going to do that in a separate thread
            # not to freeze the UI while the image is loading.
            
            # See: loadimage() function for the continuation of this. 
            
            t = threading.Thread(target=loadimage, args=(layer, win ,path, x, y, width, height, fit, cell))
            t.start()
            
    #loading it back
    else:
        if win.images[cell][path]["image"] and win.images[cell][path]["image"] != "download_button":
            imagesurface = win.images[cell][path]["image"]
            
            # Writting the image to the screen
            
            
            try:
                if "icons" in win.color and "settings/themes/" in path:

                    UI_color.set(layer, win, "icons")
                    layer.rectangle(x,y,0,0)
                    layer.fill()

                    layer.mask_surface(imagesurface, x, y)

                    UI_color.set(layer, win, "icons")
                    layer.fill()
                else: 
                    layer.set_source_surface(imagesurface, x, y)
                    layer.paint()
            except:
                pass
            
            # And if testing
            
            if win.current["testing"]:
                UI_color.set(layer, win, "testing_image")
                layer.rectangle(x,y,imagesurface.get_width(),imagesurface.get_height())
                layer.stroke()
                
        elif win.images[cell][path]["image"] == "download_button":

            # If the image is online. By default it will not load it unless the
            # user presses a download button. So here it is.
    
            def do():
                win.images[cell][path]["image"] = "downloading"
                loadimage(layer, win ,path, x, y, width, height, fit, cell)
                win.images[cell][path]["loading"] = True

                # Some link image will be automatically clicked. This
                # fixes the problem.
                win.current["LMB"] = False
                win.previous["LMB"] = False

                
            if win.settings["auto_download_images"]:
                t = threading.Thread(target=do)
                t.start()
            else:
                
                roundrect(layer, win,  x,y,40,40,10,
                          icon="image_link",
                          button=do,
                          offset=offset,
                          tip=path)
                

def tooltip(win, text):
    
    layer = win.tooltip
    
    # This function draws a tooltip helper window. 
    
    # Just in case
    text = str(text)
    
    # Let's get dimantions of the cube first.
    lines = 0
    maxletters = 0
    
    for line in text.split("\n"):
        lines += 1
        
        if len(line) > maxletters:
            maxletters = len(line)
    
    
    # Now when we now the mount of lines and the max lenght of a line. We can
    # start actually drawing something.
    
    # Let's try to make so it's not out of the frame.
    sx = win.current["mx"]
    sy = win.current["my"]
    
    if sx+(maxletters*9)+40 > win.current["w"]:
        sx = win.current["w"] - ((maxletters*9)+40)
    if sy+(lines*20)+10 > win.current["h"]:
        sy = win.current["h"] - ((lines*20)+10)   
    
    # Rectangle
    UI_color.set(layer, win, "node_background")
    roundrect(layer, win,
    sx,
    sy,
    (maxletters*9)+40,
    (lines*20)+10,
    10)
    
    
    # Text it self
    layer.select_font_face("Monospace", cairo.FONT_SLANT_NORMAL,
                                        cairo.FONT_WEIGHT_NORMAL)
    layer.set_font_size(15)
    UI_color.set(layer, win, "text_normal")
    
    for num, line in enumerate(text.split("\n")):
        layer.move_to(sx+20,
                      sy+20+(20*num) )
        layer.show_text(line)
        
def scroll_area(layer, win, name, x, y, width, height, maxlength, 
                           bar=False,sideways=False, mmb=False, mmb_only=False,
                           url="", strenght=50, bar_always=False):
    
    # This function going to handle all the scrolling windows. Making it so it's
    # relativelly simple to set up big widgets with in small areas. 
    # It will handle only the value of the scroll stored in win.scroll[name]
    
    if maxlength == 0:
        maxlength = 1
    
    x = int(x)
    y = int(y)
    width = int(width)
    height = int(height)
    
    # First let's set one up if it's not setup
    if name not in win.scroll:
        win.scroll[name] = 0
        return
    
    # Getting scroll amount based on all kinds of settings. AT THIS MOMENT
    # IT'S IN AN ALPHA BECAUSE I'M LAZY. I GONNA IMPLEMENT THING AS I NEED THEM
    # Or you can do that. IDK...
    
    amount = 0.0
    if  win.current['mx'] in range(x, x+width) \
    and win.current['my'] in range(y, y+height) :
        if not mmb_only:
            
            amount = win.current["scroll"][1]*strenght
            
                
        if mmb_only:
            mmb = True
        
        # Middle mouse button scroll, or using a graphical tablet.
        if mmb:
            if win.current["MMB"]:
                if not sideways:
                    amount = 0 - ( win.current["my"] - win.previous["my"] )
                else:
                    amount = 0 - ( win.current["mx"] - win.previous["mx"] )
                
    # I guess I need to separate the logic into a separate minifunction.
    # I will use later for the scroll bar thingy. So not to rewrite the code
    # Here is a function thingy.
    
    def logic():
        if url and url != win.url:
            return
        # Scroll logic
        win.scroll[name] -= amount
        
        if not sideways:
            # If too low  
            if win.scroll[name] < (1-maxlength+height):
                win.scroll[name] = (1-maxlength+height)
            # If too high
            if win.scroll[name] > 0:
                win.scroll[name] = 0    
        else:
            # If too low  
            if win.scroll[name] < (1-maxlength+width):
                win.scroll[name] = (1-maxlength+width)
            # If too high
            if win.scroll[name] > 0:
                win.scroll[name] = 0 
    logic()
    # Not BAR. Which is going to be drawn at a side of what ever content there
    # Basically a scrollbar. But implemented from scratch. Because I'm crazy.
    # and have nothing better to do now.
    
    if bar:
        
        # For now I'm going to implement only vertical bar. I gonna implement
        # the horisontal one when the time comes.
        
        if not sideways:
            
            # Fist let's make some math in front. Because things like this
            # require ton of maths. And it's good to have some predone.
            
            tobreak = False # Also if we can abort the operation early with it.
            fraction = height / maxlength # Similar to progress bar for now
            if fraction > 1:
                tobreak = True
                fraction = 1
            
            # To break parameter basically says. To draw it the bar only when 
            # it's actully needed. When content aka maxlength is bigger then
            # our viewport.
            
            if not tobreak or bar_always:
                
                # Now the offset value. That will move our progress bar with 
                # the scroll value.
                
                offset = (height-60)*( (1-win.scroll[name])  / maxlength )        
                
                # Background bar
                
                UI_color.set(layer, win, "background")
                roundrect(layer, win,
                (x+width)-20,
                y+30,
                10,
                height-60,
                5
                )
                
                # Active bar
                
                UI_color.set(layer, win, "button_active")
                
                # Let's save a little bit more math because it's going to be
                # vild. And I love it.
                
                Lx  = (x+width)-20
                LSx = 10
                Ly  = y+30+offset
                LSy = (height-60)*fraction
                
                # Mouse over thingy. To make the bat a tiny bit brighter. 
                # indicating to the user that it's now could be used.
                
                if  win.current['mx'] in range(int(Lx), int(Lx+LSx)) \
                and win.current['my'] in range(int(Ly), int(Lx+LSy)) :
                    UI_color.set(layer, win, "button_clicked")
                
                # Now separatelly we gonna check for if the mouse pressed. 
                # Remember if it's not pressed it's False. It's written in one
                # of the files. Basically I want to be able to move the mouse
                # outside the bar while moving. And so it won't cancel the motion.
                
                # It seems like I did something wrong. Anyways it works.
                
                if win.current["LMB"]:
                    if  int(win.current['LMB'][0]) in range(int(Lx), int(Lx+LSx)) \
                    and int(win.current['LMB'][1]) in range(int(y), int(y+(height-60))) :
                        
                        UI_color.set(layer, win, "button_clicked")
                        
                        # A bit more math to set the value back.
                        amount = ( win.current["my"] - win.previous["my"] ) / \
                                   (height-60) * maxlength
                        logic() # Yeah. Look a few lines back.
                
                # And only after all of this nonsense we can draw the cube. Or
                # should I say roundrect? A button? Aaaaaa.... 
                
                roundrect(layer, win,
                Lx,
                Ly,
                LSx,
                LSy,
                5
                )

        else:
            
            # Fist let's make some math in front. Because things like this
            # require ton of maths. And it's good to have some predone.
            
            tobreak = False # Also if we can abort the operation early with it.
            fraction = width / maxlength # Similar to progress bar for now
            if fraction > 1:
                tobreak = True
                fraction = 1
            
            # To break parameter basically says. To draw it the bar only when 
            # it's actully needed. When content aka maxlength is bigger then
            # our viewport.
            
            if not tobreak or bar_always:
                
                # Now the offset value. That will move our progress bar with 
                # the scroll value.
                
                offset = (width-60)*( (1-win.scroll[name])  / maxlength )        
                
                # Background bar
                
                UI_color.set(layer, win, "background")
                roundrect(layer, win,
                x+30,
                (y+height)-20,
                width-60,
                10,
                5
                )
                
                # Active bar
                
                UI_color.set(layer, win, "button_active")
                
                # Let's save a little bit more math because it's going to be
                # vild. And I love it.
                
                Lx  = (y+height)-20
                LSx = 10
                Ly  = x+30+offset
                LSy = (width-60)*fraction
                
                # Mouse over thingy. To make the bat a tiny bit brighter. 
                # indicating to the user that it's now could be used.
                
                if  win.current['my'] in range(int(Lx), int(Lx+LSx)) \
                and win.current['mx'] in range(int(Ly), int(Lx+LSy)) :
                    UI_color.set(layer, win, "button_clicked")
                
                # Now separatelly we gonna check for if the mouse pressed. 
                # Remember if it's not pressed it's False. It's written in one
                # of the files. Basically I want to be able to move the mouse
                # outside the bar while moving. And so it won't cancel the motion.
                
                # It seems like I did something wrong. Anyways it works.
                
                if win.current["LMB"]:
                    if  int(win.current['LMB'][1]) in range(int(Lx), int(Lx+LSx)) \
                    and int(win.current['LMB'][0]) in range(int(x), int(x+(width-60))) :
                        
                        UI_color.set(layer, win, "button_clicked")
                        
                        # A bit more math to set the value back.
                        amount = ( win.current["mx"] - win.previous["mx"] ) / \
                                   (width-60) * maxlength
                        logic() # Yeah. Look a few lines back.
                
                # And only after all of this nonsense we can draw the cube. Or
                # should I say roundrect? A button? Aaaaaa.... 
                
                roundrect(layer, win,
                Ly,
                Lx,
                LSy,
                LSx,
                5
                )

def text(outlayer, win, name, x, y, width, height, set_text="", parse=False, fill=True,
        editable=True, multiline=False , linebreak=False, centered=False, tip="",
        offset=[0,0]):
    
    # This function will handle all the text writting in the software.
    # I'm not sure about how parsing going to work for script files later. 
    # But if it's currently works, means that I already implemented it into 
    # the program. 
    
    # Making the layer
    surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(width), int(height))
    layer = cairo.Context(surface)
    layer.select_font_face("Monospace", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
    layer.set_font_size(20)
    
    # Some challenges that it will have is how to correctly store data about
    # the text in the system. I think we can use the win.text variable to store
    # directories of the data.
    
    if name not in win.text:
        
        # I need to get something done before I can pu scroll in.
        scrollname = name
        while scrollname in win.scroll:
            scrollname = scrollname+"_text"
        
        win.text[name] = {
            "text"  :set_text,  # Actuall text you are editing.
            "cursor":[len(str(set_text)),len(str(set_text))], # Cursor
            "insert":False, # Whether the insert mode is on
            "scroll":scrollname # If multiline. The pointer for the scroll value.
            }
    
    # Background
    if fill:
        UI_color.set(layer, win, "darker_parts")
        roundrect(layer, win, 
            0,
            0,
            width,
            height,
            10)
        layer.fill()
    
    # Now after filling it up. I want to clip everything. SO no text will get
    # out of a given area. 
    roundrect(layer, win, 
        0,
        0,
        width,
        height,
        10, 
        fill=False)
    layer.clip()
    
    # Now I want to give a preview of the text it self. BUT. I need to be sure 
    # that if the text longer then a given width and there is no multiline or a
    # linebreak. Then it scrolls sideways to the cursor. 
    
    # Automatic scroll system: Based on the position of the cursor.
    offsetX = 0
    cursor2location = win.text[name]["cursor"][1]*12 + offsetX
    while cursor2location > width - 5:
        offsetX -= 1
        cursor2location = win.text[name]["cursor"][1]*12 + offsetX
        
    
    # Text selection. AKA cursor
    # So here we draw the cursor
    if editable:
        UI_color.set(layer, win, "node_blendfile")
        if win.text[name]["cursor"][0] == win.text[name]["cursor"][1]: 
            if win.blink:
                layer.rectangle(
                    win.text[name]["cursor"][0]*12+5 +offsetX,
                    5,
                    (win.text[name]["cursor"][1]*12)-(win.text[name]["cursor"][0]*12)+2,
                    30
                    )
        else:
            roundrect(layer, win, 
                win.text[name]["cursor"][0]*12+5 +offsetX,
                5,
                (win.text[name]["cursor"][1]*12)-(win.text[name]["cursor"][0]*12)+2,
                30,
                5,
                fill=False
                )
        if win.textactive == name:
            layer.fill()
        elif win.text[name]["cursor"][0] != win.text[name]["cursor"][1]:
            layer.stroke()
    
    
    # Making sure that cursor is correct. Because a lot of bugs are happening
    # with it and it's not cool.
    
    # Mouse select
    if win.current["LMB"]:
        if int(win.current["mx"]-offset[0]) in range(int(x), int(x+width))\
        and int(win.current["my"]-offset[1]) in range(int(y), int(y+height)):
            win.text[name]["cursor"][0] = int((win.current["LMB"][0]-x-offsetX-offset[0])/12)
            win.text[name]["cursor"][1] = int((win.current["mx"]-x-offsetX-offset[0])/12)
            
    # If second part of selection ends up bigger then the first. Reverse them.
    if win.text[name]["cursor"][0] > win.text[name]["cursor"][1]:
        win.text[name]["cursor"] = [
            win.text[name]["cursor"][1],
            win.text[name]["cursor"][0]]
    
    # If any part ends up beyond the text. Clip them in.
    if win.text[name]["cursor"][0] < 0:
        win.text[name]["cursor"][0] = 0
    if win.text[name]["cursor"][1] < 0:
        win.text[name]["cursor"][1] = 0
    if win.text[name]["cursor"][0] > len(str(win.text[name]["text"])):
        win.text[name]["cursor"][0] = len(str(win.text[name]["text"]))
    if win.text[name]["cursor"][1] > len(str(win.text[name]["text"])):
        win.text[name]["cursor"][1] = len(str(win.text[name]["text"]))
    
    
    
    # Drawing the text
    
    UI_color.set(layer, win, "text_normal")
    layer.move_to(5+offsetX, height/2+5)
    if centered:
        layer.move_to(width/2-len(str(win.text[name]["text"]))*12/2, height/2+5)
    layer.show_text(str(win.text[name]["text"]))
    
    # Editing the text
    if win.current["keys"] and editable and name == win.textactive:
        # Let's filter the input first. 
        # For example
        if not multiline: #Removing enter key press
            if 65293 in win.current["keys"] or 65421 in win.current["keys"]\
            or 65289 in win.current["keys"]:  # TAB
                win.current["key_letter"] = ""
            
        
        prevlen = len(win.text[name]["text"])
        clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
        regularclean = True
        ORD = 0
        try:
            ORD = ord(win.current["key_letter"])
        except:
            pass
        backremove = False # Whether to make selection go to 0 width thing
        #print(ORD, win.text[name]["cursor"][0])
        
        
        # Backspace
        if 65288 in win.current["keys"]:
            if win.text[name]["cursor"][0] != 0 and win.text[name]["cursor"][0]\
                                           == win.text[name]["cursor"][1]:
                
                win.text[name]["text"] = win.text[name]["text"]\
                [:win.text[name]["cursor"][0]-1]+\
                 win.text[name]["text"]\
                [win.text[name]["cursor"][1]:]
                
            elif win.text[name]["cursor"][1] != 0 and win.text[name]["cursor"][0]\
                                           != win.text[name]["cursor"][1]:
                                           
                win.text[name]["text"] = win.text[name]["text"]\
                [:win.text[name]["cursor"][0]]+\
                 win.text[name]["text"]\
                [win.text[name]["cursor"][1]:]
                backremove = True
            
        # Ctrl - C
        elif ORD == 3:
            clipboard.set_text( win.text[name]["text"]\
            [win.text[name]["cursor"][0]:win.text[name]["cursor"][1]], -1)
        
        # Ctrl - V
        elif ORD == 22:
            
            cliptext = str(clipboard.wait_for_text())
            
            win.text[name]["text"] = win.text[name]["text"]\
            [:win.text[name]["cursor"][0]]\
             + cliptext +\
            win.text[name]["text"]\
            [win.text[name]["cursor"][1]:]
            win.text[name]["cursor"][0] = win.text[name]["cursor"][1]
        
        # Ctrl - A
        elif ORD == 1:
            win.text[name]["cursor"][0] = 0
            win.text[name]["cursor"][1] = len(win.text[name]["text"])
        
        # To clear up the Controll
        elif 65507 in win.current["keys"]:
            pass
        
        # Shift
        elif 65506 in win.current["keys"]:
            # Right
            if 65363 in win.current["keys"]:
                win.text[name]["cursor"][1] = win.text[name]["cursor"][1] + 1
                #win.current["keys"].remove(65363)
            
            # Left
            elif 65361 in win.current["keys"]:
                if win.text[name]["cursor"][1] > win.text[name]["cursor"][0]:
                    win.text[name]["cursor"][1] = win.text[name]["cursor"][1] - 1
                #win.current["keys"].remove(65361)
                
        # Right button
        elif 65363 in win.current["keys"]:
            win.text[name]["cursor"][0] = win.text[name]["cursor"][0] + 1
            win.text[name]["cursor"][1] = win.text[name]["cursor"][0]
            win.current["keys"].remove(65363)
        
        # Left button
        elif 65361 in win.current["keys"]:
            win.text[name]["cursor"][0] = win.text[name]["cursor"][0] - 1
            win.text[name]["cursor"][1] = win.text[name]["cursor"][0]
            win.current["keys"].remove(65361)
        
        # Escape
        elif 65307 in win.current["keys"]:
            win.textactive = ""
            win.current["keys"].remove(65307)
            
        else:
            win.text[name]["text"] = win.text[name]["text"]\
            [:win.text[name]["cursor"][0]]\
             + win.current["key_letter"]+\
            win.text[name]["text"]\
            [win.text[name]["cursor"][1]:]
            
               
        # Auto moving the cursor    
        nowlen = len(win.text[name]["text"])
        if win.text[name]["cursor"][0] == win.text[name]["cursor"][1]:
            win.text[name]["cursor"][0] = win.text[name]["cursor"][0] + (nowlen - prevlen)
            win.text[name]["cursor"][1] = win.text[name]["cursor"][0]
        
        elif backremove:
            win.text[name]["cursor"][1] = win.text[name]["cursor"][0]
        
        
        if nowlen != prevlen and regularclean:
            # Deleting all the keys from the keys. So yeah.
            win.current["keys"] = [] 
            
    
    
    
    # Outputing to the outlayer. 
    outlayer.set_source_surface(surface, x, y)
    outlayer.paint() 
    
    # Button if editable.
    if editable:
        def do():
            win.textactive = name
        roundrect(outlayer, win, 
            x,
            y,
            width,
            height,
            10, 
            fill=False,
            button=do,
            tip=tip,
            offset=offset,
            text=True)
        outlayer.stroke()
    
    if win.textactive == name:
        UI_color.set(outlayer, win, "button_active")
        roundrect(outlayer, win, 
            x,
            y,
            width,
            height,
            10, 
            fill=False)
        outlayer.stroke()