easycoder 241218.1__py2.py3-none-any.whl → 241231.1__py2.py3-none-any.whl

easycoder/ec_renderer.py

@@ -1,335 +1,245 @@
-# renderer.py
-
-import sys, json
-import tkinter as tk
-from PIL import Image, ImageTk
-
-elements = {}
-zlist = []
-images = {}
-onTick = None
-
-# Set the canvas
-def setCanvas(c):
-    global canvas
-    canvas = c
-
-# Get the canvas
-def getCanvas():
-    global canvas
-    return canvas
-
-def createScreen(values):
-    global screen, canvas, screenLeft, screenTop, running
-    running = True
-    screen = tk.Tk()
-    screen.title('EasyCoder')
-    # screen.attributes('-fullscreen', True)
+from kivy.app import App
+from kivy.uix.widget import Widget
+from kivy.uix.label import CoreLabel
+from kivy.uix.image import AsyncImage
+from kivy.core.window import Window
+from kivy.graphics import Color, Ellipse, Rectangle
+from kivy.utils import colormap
+from kivy.clock import Clock
+from kivy.vector import Vector
+import math
+
+class Object():
+    pass
+
+class Element():
+
+    def __init__(self, type, spec):
+        self.type = type
+        self.spec = spec
+
+    def getType(self):
+        return self.spec.type
+
+    def getID(self):
+        return self.spec.id
+
+    def getRealPos(self):
+        spec = self.spec
+        pos = spec.realpos
+        if spec.parent != None:
+            pos = Vector(pos) + spec.parent.realpos
+        return pos
+
+    def getPos(self):
+        spec = self.spec
+        pos = spec.pos
+        if spec.parent != None:
+            pos = Vector(pos) + spec.parent.pos
+        return pos
+
+    def setPos(self, pos):
+        self.spec.realpos = pos
+        self.spec.item.pos = pos
+    
+    # Called when the parent moves
+    def repos(self):
+        spec = self.spec
+        spec.item.pos = Vector(spec.realpos) + spec.parent.realpos
+            
+    def getRealSize(self):
+        return self.spec.realsize
+            
+    def getSize(self):
+        return self.spec.size
+
+    def setSize(self, size):
+        self.spec.size = size
+    
+    def getChildren(self):
+        return self.spec.children
 
-    # screen.overrideredirect(True)
-    width = values['width']['content'] if 'width' in values else 600
-    height = values['height']['content'] if 'height' in values else 800
-    screenLeft = int((screen.winfo_screenwidth() - width) / 2)
-    screenTop = int((screen.winfo_screenheight() - height) / 2)
-    if 'left' in values:
-        screenLeft = values['left']['content']
-    if 'top' in values:
-        screenTop = values['top']['content'] 
+class UI(Widget):
 
-    geometry = str(width) + 'x' + str(height) + '+' + str(screenLeft) + '+' + str(screenTop) 
-    screen.geometry(geometry)
+    elements = {}
+    zlist = []
 
-    # Handle a click in the screen
-    def onClick(event):
-        global screenLeft, screenTop, zlist
-        x = event.x
-        y = event.y
-        # print('Clicked at : '+ str(x) +","+ str(y))
-        for i in range(1, len(zlist) + 1):
-            element = zlist[-i]
-            id = list(element)[0]
-            values = element[id]
-            x1 = values['left']
-            x2 = x1 + values['width'] + getScreenLeft(values['parent'])
-            y1 = values['top'] + getScreenTop(values['parent'])
-            y2 = y1 + values['height']
-            if x >= x1 and x < x2 and y >= y1 and y < y2:
-                if id in elements:
-                    element = elements[id]
-                    if 'cb' in element:
-                        element['cb']()
-                        break
+    def getElement(self, id):
+        if id in self.elements.keys():
+            return self.elements[id]
+        return None
+    
+    def addElement(self, id, spec):
+        if id in self.elements.keys():
+            raise(Exception(f'Element {id} already exists'))
+        element = Element(type, spec)
+        element.cb = None
+        self.elements[id] = element
+        self.zlist.append(element)
+
+    def createElement(self, spec):
+        # Get a real position or size value
+        def getReal(val):
+            if isinstance(val, str):
+                c = val[-1]
+                if c in ['w', 'h']:
+                    val = int(val[0:len(val)-1])
+                    if spec.parent == None:
+                        if c == 'w':
+                            n = Window.width
+                        else:
+                            n = Window.height
+                    else:
+                        if c == 'w':
+                            n = spec.parent.realsize[0]
+                        else:
+                            n = spec.parent.realsize[1]
+                    return val * n / 100
+            return val
+
+        with self.canvas:
+            if hasattr(spec, 'fill'):
+                c = spec.fill
+                if isinstance(c, str):
+                    c = colormap[c]
+                    Color(c[0], c[1], c[2])
                 else:
-                    RuntimeError(None, f'Element \'{id}\' does not exist')
-
-    screen.bind('<Button-1>', onClick)
-
-    fill = values['fill']['content'] if 'fill' in values else 'white'
-    canvas = tk.Canvas(master=screen, width=width, height=height, bg=fill)
-    canvas.place(x=0, y=0)
-    setCanvas(canvas)
-
-# Close the screen
-def closeScreen():
-    global screen
-    screen.destroy()
-
-# Set up a click handler in an element
-def setOnClick(id, cb):
-    global elements
-    if id in elements:
-        elements[id]['cb'] = cb
-    else:
-        RuntimeError(None, f'Element \'{id}\' does not exist')
-    return
-
-# Set up the tick handler
-def setOnTick(cb):
-    global onTick
-    onTick = cb
-
-# Show the screen and issue tick callbacks
-def showScreen():
-    global screen, onTick
-    def afterCB(screen):
-        if onTick != None:
-            onTick()
-        screen.after(100, lambda: afterCB(screen))
-    screen.after(1000, lambda: afterCB(screen))
-    screen.mainloop()
-    sys.exit()
-
-# Render a graphic specification
-def render(spec, parent):
-    global elements
-
-    def getValue(args, item):
-        if item in args:
-            if type(item) == int:
-                return item
-            return args[item]
-        return item
-
-    def renderIntoRectangle(widgetType, values, parent, args):
-        global zlist
-        left = getValue(args, values['left']) if 'left' in values else 10
-        screenLeft = left + getScreenLeft(parent)
-        top = getValue(args, values['top']) if 'top' in values else 10
-        screenTop = top + getScreenTop(parent)
-        width = getValue(args, values['width']) if 'width' in values else 100
-        height = getValue(args, values['height']) if 'height' in values else 100
-        right = screenLeft + width
-        bottom = screenTop + height
-        fill = values['fill'] if 'fill' in values else None
-        outline = values['outline'] if 'outline' in values else None
-        if outline != None:
-            outlineWidth = getValue(args, values['outlineWidth']) if 'outlineWidth' in values else 1
-        else:
-            outlineWidth = 0
-        if widgetType == 'rectangle':
-            widgetId = getCanvas().create_rectangle(screenLeft, screenTop, right, bottom, fill=fill, outline=outline, width=outlineWidth)
-        elif widgetType == 'ellipse':
-            widgetId = getCanvas().create_oval(screenLeft, screenTop, right, bottom, fill=fill, outline=outline, width=outlineWidth)
-        else:
-            return f'Unknown widget type \'{widgetType}\''
-        if 'name' in values:
-            widgetName = getValue(args, values['name'])
-        else:
-            widgetName = None
-        widgetSpec = {
-            "type": widgetType,
-            "name": widgetName,
-            "id": widgetId,
-            "left": left,
-            "top": top,
-            "width": width,
-            "height": height,
-            "parent": parent,
-            "children": []
-        }
-        elements[widgetName] = widgetSpec
-        zlist.append({widgetName: widgetSpec})
-        if '#' in values:
-            children = values['#']
-            if type(children) == list:
-                for item in children:
-                    if item in values:
-                        child = values[item]
-                        childSpec = renderWidget(child, widgetSpec, args)
-                        widgetSpec['children'].append(childSpec['name'])
-            else:
-                child = values[children]
-                childSpec = renderWidget(child, widgetSpec, args)
-                widgetSpec['children'].append(childSpec['name'])
-        return widgetSpec
-   
-    def renderText(values, parent, args):
-        left = getValue(args, values['left']) if 'left' in values else 10
-        screenLeft = left + getScreenLeft(parent)
-        top = getValue(args, values['top']) if 'top' in values else 10
-        screenTop = top + getScreenTop(parent)
-        width = getValue(args, values['width']) if 'width' in values else 100
-        height = getValue(args, values['height']) if 'height' in values else 100
-        shape = getValue(args, values['shape']) if 'shape' in values else 'rectangle'
-        outline = getValue(args, values['outline']) if 'outline' in values else None
-        color = getValue(args, values['color']) if 'color' in values else None
-        text = getValue(args, values['text']) if 'text' in values else ''
-        fontFace = getValue(args, values['fontFace']) if 'fontFace' in values else 'Helvetica'
-        fontWeight = getValue(args, values['fontWeight']) if 'fontWeight' in values else 'normal'
-        fontTop = int(round(screenTop + height/2))
-        if 'fontSize' in values:
-            fontSize = getValue(args, values['fontSize'])
-            fontTop = int(round(screenTop + height/2 - fontSize/4))
-        else:
-            fontSize = int(round(height*2/5) if shape == 'ellipse' else round(height*3/5))
-            fontTop -= int(round(screenTop + height/2 - fontSize/5))
-        adjust = int(round(fontSize/5)) if shape == 'ellipse' else 0
-        align = getValue(args, values['align']) if 'align' in values else 'center'
-        if align == 'left':
-            xoff = int(round(fontSize/5))
-            anchor = 'w'
-        elif align == 'right':
-            xoff = width - int(round(fontSize/5))
-            anchor = 'e'
-        else:
-            xoff = int(round(width/2))
-            anchor = 'center'
-        if xoff < 3:
-            xoff = 3
-        xoff -= int(round(fontSize/4))
-        textId = canvas.create_text(screenLeft + xoff, fontTop + adjust, fill=color, font=f'"{fontFace}" {fontSize} {fontWeight}', text=text, anchor=anchor)
-        if 'name' in values:
-            widgetName = getValue(args, values['name'])
+                    Color(c[0]/255, c[1]/255, c[2]/255)
+            pos = (getReal(spec.pos[0]), getReal(spec.pos[1]))
+            spec.realpos = pos
+            size = (getReal(spec.size[0]), getReal(spec.size[1]))
+            spec.realsize = size
+            if spec.parent != None:
+                pos = Vector(pos) + spec.parent.realpos
+            if spec.type == 'ellipse':
+                item = Ellipse(pos=pos, size=size)
+            elif spec.type == 'rectangle':
+                item = Rectangle(pos=pos, size=size)
+            elif spec.type == 'text':
+                if hasattr(spec, 'color'):
+                    c = spec.color
+                    if isinstance(c, str):
+                        c = colormap[c]
+                        Color(c[0], c[1], c[2])
+                    else:
+                        Color(c[0]/255, c[1]/255, c[2]/255)
+                else:
+                    Color(1, 1, 1, 1)
+                label = CoreLabel(text=spec.text, font_size=1000, halign='center', valign='center')
+                label.refresh()
+                text = label.texture
+                item = Rectangle(pos=pos, size=size, texture=text)
+            elif spec.type == 'image':
+                item = AsyncImage(pos=pos, size=size, source=spec.source)
+            spec.item = item
+            self.addElement(spec.id, spec)
+    
+    def moveElementBy(self, id, dist):
+        element = self.getElement(id)
+        if element != None:
+            element.setPos(Vector(element.getRealPos()) + dist)
+            for id in element.getChildren():
+                self.getElement(id).repos()
+        return
+    
+    def moveElementTo(self, id, pos):
+        element = self.getElement(id)
+        if element != None:
+            self.moveElementBy(id, Vector(pos) - element.getRealPos())
+        return
+
+    def on_touch_down(self, touch):
+        tp = touch.pos
+        x = tp[0]
+        y = tp[1]
+        for element in reversed(self.zlist):
+            if element.cb != None:
+                spec = element.spec
+                pos = self.getRealPos()
+                if spec.parent != None:
+                    pos = Vector(pos) + spec.parent.getRealPos()
+                size = spec.size
+                if spec.type == 'ellipse':
+                    a = size[0]/2
+                    b = size[1]/2
+                    ctr = (pos[0] + a, pos[1] +b)
+                    h = ctr[0]
+                    k = ctr[1]
+                    if (math.pow((x - h), 2) / math.pow(a, 2)) + (math.pow((y - k), 2) / math.pow(b, 2)) <= 1:
+                        element.cb()
+                        break
+                elif spec.type in ['rectangle', 'text', 'image']:
+                    if tp[0] >= pos[0] and tp[0] < pos[0] + size[0] and tp[1] >= pos[1] and tp[1] < pos[1] + size[1]:
+                        element.cb()
+                        break
+    
+    def setOnClick(self, id, callback):
+        self.getElement(id).cb = callback
+
+    def getWindowAttribute(self, attribute):
+        if attribute == 'left':
+            return Window.left
+        elif attribute == 'top':
+            return Window.top
+        elif attribute == 'width':
+            return Window.size[0]
+        elif attribute == 'height':
+            return Window.size[1]
         else:
-            widgetName = None
-        widgetSpec = {
-            "type": "text",
-            "name": widgetName,
-            "id": textId,
-            "left": left,
-            "top": top,
-            "width": width,
-            "height": height,
-            "parent": parent
-        }
-        elements[widgetName] = widgetSpec
-        zlist.append({widgetName: widgetSpec})
-        return widgetSpec
-
-    def renderImage(values, parent, args):
-        global images
-        left = getValue(args, values['left']) if 'left' in values else 10
-        screenLeft = left + getScreenLeft(parent)
-        top = getValue(args, values['top']) if 'top' in values else 10
-        screenTop = top + getScreenTop(parent)
-        width = getValue(args, values['width']) if 'width' in values else 100
-        source = getValue(args, values['source']) if 'source' in values else None
-        if 'name' in values:
-            widgetName = values['name']
+            raise Exception(f'Unknown attribute: {attribute}')
+
+    def getAttribute(self, id, attribute):
+        spec = self.getElement(id).spec
+        if attribute == 'left':
+            return spec.realpos[0]
+        elif attribute == 'bottom':
+            return spec.realpos[1]
+        elif attribute == 'width':
+            return spec.realsize[0]
+        elif attribute == 'height':
+            return spec.realsize[1]
         else:
-            widgetName = None
-        if source == None:
-            raise(Exception(f'No image source given for \'{id}\''))
-        img = (Image.open(source))
-        height = int(round(img.height * width / img.width))
-        resized_image= img.resize((width, height), Image.LANCZOS)
-        new_image= ImageTk.PhotoImage(resized_image)
-        imageid = getCanvas().create_image(screenLeft, screenTop, anchor='nw', image=new_image)
-        images[widgetName] = {'id': imageid, "image": new_image}
-        widgetSpec = {
-            "type": "image",
-            "nme": widgetName,
-            "left": left,
-            "top": top,
-            "width": width,
-            "height": height,
-            "source": source,
-            "parent": parent
-        }
-        elements[widgetName] = widgetSpec
-        zlist.append({widgetName: widgetSpec})
-        return widgetSpec
-
-    # Create a canvas or render a widget
-    def renderWidget(widget, parent, args):
-        widgetType = widget['type']
-        if widgetType in ['rectangle', 'ellipse']:
-            return renderIntoRectangle(widgetType, widget, parent, args)
-        elif widgetType == 'text':
-            return renderText(widget, parent, args)
-        elif widgetType == 'image':
-            return renderImage(widget, parent, args)
-
-    # Render a complete specification
-    def renderSpec(spec, parent, args):
-        widgets = spec['#']
-        # If a list, iterate it
-        if type(widgets) is list:
-            for widget in widgets:
-                renderWidget(spec[widget], parent, args)
-        # Otherwise, process the single widget
+            raise Exception(f'Unknown attribute: {attribute}')
+        
+    def setAttribute(self, id, attribute, value):
+        spec = self.getElement(id).spec
+        if attribute == 'left':
+            spec.realpos = (value, spec.realsize[0])
+            spec.item.pos = (value, spec.realsize[0])
+        elif attribute == 'bottom':
+            spec.realpos = (spec.realsize[0], value)
+            spec.item.pos = (spec.realsize[0], value)
+        elif attribute == 'width':
+            spec.realsize = (value, spec.realsize[0])
+            spec.item.size = (value, spec.realsize[0])
+        elif attribute == 'height':
+            spec.realsize = (spec.realsize[0], value)
+            spec.item.size = (spec.realsize[0], value)
         else:
-            renderWidget(spec[widgets], parent, args)
+            raise Exception(f'Unknown attribute: {attribute}')
 
-    # Main entry point
-    if parent != screen:
-        RuntimeError(None, 'Can\'t yet render into parent widget')
+class Renderer(App):
 
-    # If it'a string, process it
-    if type(spec) is str:
-        renderSpec(json.loads(spec), None, {})
-
-    # If it's a 'dict', extract the spec and the args
-    if type(spec) is dict:
-        args = spec['args']
-        spec = json.loads(spec['spec'])
-        renderSpec(spec, None, args)
-
-# Get the widget whose name is given
-def getElement(name):
-    global elements
-    if name in elements:
-        return elements[name]
-    else:
-        RuntimeError(None, f'Element \'{name}\' does not exist')
-
-# Set the content of a text widget
-def setText(name, value):
-    getCanvas().itemconfig(getElement(name)['id'], text=value)
-
-# Set the background of a rectangle or ellipse widget
-def setBackground(name, value):
-    id = getElement(name)['id']
-    getCanvas().itemconfig(getElement(name)['id'], fill=value)
+    def getUI(self):
+        return self.ui
     
-# Move an element by an amount
-def moveElement(name, dx, dy):
-    element = getElement(name)
-    getCanvas().move(element['id'], dx, dy)
-    element['left'] += dx
-    element['top'] += dy
-    for childName in element['children']:
-        element = getElement(childName)
-        getCanvas().move(element['id'], dx, dy)
-
-# Move an element to a new location
-def moveElementTo(name, left, top):
-    element = getElement(name)
-    moveElement(name, left - element['left'], top - element['top'])
-
-# Get an attribute of an element
-def getAttribute(name, attribute):
-    element = getElement(name)
-    return element[attribute]
-
-# Get the screen left position of an element
-def getScreenLeft(element):
-    if element == None:
-        return 0
-    return element['left'] + getScreenLeft(element['parent'])
-
-# Get the screen top position of an element
-def getScreenTop(element):
-    if element == None:
-        return 0
-    return element['top'] + getScreenTop(element['parent'])
+    def request_close(self):
+        print('close window')
+        Window.close()
+    
+    def flushQueue(self, dt):
+        self.flush()
+    
+    def build(self):
+        Clock.schedule_interval(self.flushQueue, 0.01)
+        self.ui = UI()
+        return self.ui
+
+    def init(self, spec):
+        self.title = spec.title
+        self.flush = spec.flush
+        Window.size = spec.size
+        Window.left = spec.pos[0]
+        Window.top = spec.pos[1]
+        Window.clearcolor = spec.fill
+        Window.on_request_close=self.request_close

easycoder/ec_screenspec.py

@@ -0,0 +1,77 @@
+# screenspec.py
+
+from json import loads
+from .ec_renderer import Object
+
+class ScreenSpec():
+
+    # Get an attribute of an element
+    def getAttribute(self, id, attribute):
+        element = self.ui.getElement(id)
+        return element[attribute]
+
+    # Render a single widget
+    def createWidget(self, widget, parent):
+        spec = Object()
+        type = widget['type']
+        spec.type = type
+        spec.id = widget['id']
+        spec.pos = (widget['left'], widget['bottom'])
+        spec.size = (widget['width'], widget['height'])
+        if widget.get('fill') != None:
+            spec.fill = widget['fill']
+        if widget.get('text') != None:
+            spec.text = widget['text']
+        if widget.get('fontSize') != None:
+            spec.fontSize = widget['fontSize']
+        if widget.get('source') != None:
+            spec.source = widget['source']
+        if widget.get('color') != None:
+            spec.color = widget['color']
+        spec.parent = parent
+        spec.children = []
+        self.ui.createElement(spec)
+
+        if '#' in widget:
+            children = widget['#']
+            if isinstance(children, list):
+                for item in children:
+                    if item in widget:
+                        child = widget[item]
+                        childSpec = self.createWidget(child, spec)
+                        spec.children.append(childSpec.id)
+                    else:
+                        raise Exception(f'Child \'{item}\' is missing')
+            else:
+                child = widget[children]
+                childSpec = self.createWidget(child, spec)
+                spec.children.append(childSpec.id)
+
+        return spec
+
+    # Render a complete specification
+    def renderSpec(self, spec, parent):
+        widgets = spec['#']
+        # If a list, iterate it
+        if isinstance(widgets, list):
+            for widget in widgets:
+                self.createWidget(spec[widget], parent)
+        # Otherwise, process the single widget
+        else:
+            self.createWidget(spec[widgets], parent)
+
+    # Render a graphic specification
+    def render(self, spec, ui):
+        self.ui = ui
+
+        # If it'a string, process it
+        if isinstance(spec, str):
+            self.renderSpec(loads(spec), None)
+
+        # If it's a 'dict', extract the spec and the args
+        elif isinstance(spec, dict):
+            spec = loads(spec['spec'])
+            self.renderSpec(spec, None)
+
+        else:
+            raise Exception('Spec is an unknown type')