easycoder 250107.4__tar.gz → 250109.2__tar.gz

{easycoder-250107.4 → easycoder-250109.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: easycoder
-Version: 250107.4
+Version: 250109.2
 Summary: Rapid scripting in English
 Keywords: compiler,scripting,prototyping,programming,coding,python,low code,hypertalk,computer language,learn to code
 Author-email: Graham Trott <gtanyware@gmail.com>

{easycoder-250107.4 → easycoder-250109.2}/easycoder/__init__.py

@@ -10,4 +10,4 @@ from .ec_program import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "250107.4"
+__version__ = "250109.2"

{easycoder-250107.4 → easycoder-250109.2}/easycoder/ec_graphics.py

@@ -1,8 +1,7 @@
-import sys, threading, json
 from .ec_classes import FatalError, RuntimeError, Object
 from .ec_handler import Handler
 from .ec_screenspec import ScreenSpec
-from .ec_renderer import Renderer
+from .ec_renderer import Renderer, getUI
 from .ec_program import flush
 
 class Graphics(Handler):
@@ -32,7 +31,7 @@ class Graphics(Handler):
         targetRecord = self.getVariable(command['name'])
         keyword = targetRecord['keyword']
         id = self.getRuntimeValue(command['id'])
-        uiElement = self.ui.getElement(id)
+        uiElement = getUI().getElement(id)
         if uiElement == None:
             FatalError(self.program.compiler, f'There is no screen element with id \'{id}\'')
             return -1
@@ -122,6 +121,7 @@ class Graphics(Handler):
                 for item in ['width', 'height', 'left', 'bottom', 'r', 'g', 'b', 'text']:
                     if command[item] == None:
                         FatalError(self.program.compiler, f'Missing property \'{item}\'')
+            else: return False
             self.add(command)
             record['elementID'] = command['id']
         return False
@@ -182,7 +182,6 @@ class Graphics(Handler):
             command['source'] = source
 
     def r_create(self, command):
-
         try:
             type = command['type']
             if type == 'window':
@@ -198,8 +197,13 @@ class Graphics(Handler):
                 self.windowSpec.size = (self.getRuntimeValue(command['size'][0]), self.getRuntimeValue(command['size'][1]))
                 self.windowSpec.fill = (self.getRuntimeValue(command['fill'][0])/255, self.getRuntimeValue(command['fill'][1])/255, self.getRuntimeValue(command['fill'][2])/255)
                 self.windowCreated = True
+                self.renderer = Renderer()
+                self.renderer.init(self.windowSpec)
+                self.program.setExternalControl()
+                self.program.run(self.nextPC())
+                self.renderer.run()
             else:
-                element = self.ui.createWidget(self.getWidgetSpec(command))
+                element = getUI().createWidget(self.getWidgetSpec(command))
                 print(element)
         except Exception as e:
             RuntimeError(self.program, e)
@@ -224,10 +228,6 @@ class Graphics(Handler):
     def r_ellipse(self, command):
         return self.nextPC()
 
-    def r_getui(self, command):
-        self.ui = self.renderer.getUI()
-        return self.nextPC()
-
     # Hide an element
     def k_hide(self, command):
         if self.nextIsSymbol():
@@ -240,7 +240,7 @@ class Graphics(Handler):
         return False
 
     def r_hide(self, command):
-        self.ui.setVisible(self.getRuntimeValue(command['target']), False)
+        getUI().setVisible(self.getRuntimeValue(command['target']), False)
         return self.nextPC()
 
     def k_image(self, command):
@@ -272,12 +272,12 @@ class Graphics(Handler):
 
     def r_move(self, command):
         pos = (self.getRuntimeValue(command['x']), self.getRuntimeValue(command['y']))
-        self.ui.moveElementTo(self.getRuntimeValue(command['target']), pos)
+        getUI().moveElementTo(self.getRuntimeValue(command['target']), pos)
         return self.nextPC()
 
     def r_moveBy(self, command):
         dist = (self.getRuntimeValue(command['dx']), self.getRuntimeValue(command['dy']))
-        self.ui.moveElementBy(self.getRuntimeValue(command['target']), dist)
+        getUI().moveElementBy(self.getRuntimeValue(command['target']), dist)
         return self.nextPC()
 
     # on click/tap {element} {action}
@@ -288,7 +288,7 @@ class Graphics(Handler):
             if self.nextIsSymbol():
                 target = self.getSymbolRecord()
             else:
-                FatalError(self.program.compiler, f'{self.getToken()} is not a screen element')
+                Warning(f'{self.getToken()} is not a screen element')
                 return False
             command['target'] = target['name']
             command['goto'] = self.getPC() + 2
@@ -329,7 +329,7 @@ class Graphics(Handler):
                     data = Object()
                     data.pc = pc
                     data.index = index
-                    self.ui.setOnClick(id, data, oncb)
+                    getUI().setOnClick(id, data, oncb)
             else:
                 name = record['name']
                 RuntimeError(self.program, f'{name} is not a clickable object')
@@ -341,44 +341,30 @@ class Graphics(Handler):
     def r_rectangle(self, command):
         return self.nextPC()
 
-    # render {spec}
+    # render spec {spec}
     def k_render(self, command):
-        command['spec'] = self.nextValue()
-        command['parent'] = None
-        if self.peek() == 'in':
-            self.nextToken()
-            if self.nextIsSymbol():
-                command['parent'] = self.getSymbolRecord()['name']
-        self.add(command)
-        return True
+        if self.nextToken() in ['specification', 'spec']:
+            command['spec'] = self.nextValue()
+            command['parent'] = None
+            if self.peek() == 'in':
+                self.nextToken()
+                if self.nextIsSymbol():
+                    command['parent'] = self.getSymbolRecord()['name']
+            self.add(command)
+            return True
+        return False
 
     def r_render(self, command):
         spec = self.getRuntimeValue(command['spec'])
         parent = command['parent']
         if parent !=None:
             parent = self.getVariable(command['parent'])
-        self.ui = self.renderer.getUI()
         try:
-            ScreenSpec().render(spec, parent, self.ui)
+            ScreenSpec().render(spec, parent)
         except Exception as e:
             RuntimeError(self.program, e)
         return self.nextPC()
 
-    # run graphics
-    def k_run(self, command):
-        if self.nextIs('graphics'):
-            self.add(command)
-            return True
-        return False
-
-    def r_run(self, command):
-        self.renderer = Renderer()
-        self.renderer.init(self.windowSpec)
-        self.ui = self.renderer.getUI()
-        self.program.setExternalControl()
-        self.program.run(self.nextPC())
-        self.renderer.run()
-
     # Set something
     def k_set(self, command):
         if self.nextIs('attribute'):
@@ -405,7 +391,7 @@ class Graphics(Handler):
         target = self.getVariable(command['target'])
         id = target['value'][target['index']]['content']
         value = self.getRuntimeValue(command['value'])
-        self.ui.setAttribute(id, attribute, value)
+        getUI().setAttribute(id, attribute, value)
         return self.nextPC()
 
     # Show an element (restore it to its current position)
@@ -420,7 +406,7 @@ class Graphics(Handler):
         return False
 
     def r_show(self, command):
-        self.ui.setVisible(self.getRuntimeValue(command['target']), True)
+        getUI().setVisible(self.getRuntimeValue(command['target']), True)
         return self.nextPC()
 
     def k_text(self, command):
@@ -483,7 +469,7 @@ class Graphics(Handler):
             attribute = self.getRuntimeValue(v['attribute'])
             target = self.getVariable(v['target'])
             val = self.getSymbolValue(target)
-            v = self.ui.getAttribute(val['content'], attribute)
+            v = getUI().getAttribute(val['content'], attribute)
             value = {}
             value['type'] = 'int'
             value['content'] = int(round(v))
@@ -505,7 +491,7 @@ class Graphics(Handler):
             attribute = v['attribute']
             value = {}
             value['type'] = 'int'
-            value['content'] = int(round(self.ui.getWindowAttribute(attribute)))
+            value['content'] = int(round(getUI().getWindowAttribute(attribute)))
             return value
         except Exception as e:
             RuntimeError(self.program, e)

{easycoder-250107.4 → easycoder-250109.2}/easycoder/ec_program.py

@@ -18,7 +18,6 @@ class Program:
 
 	def __init__(self, argv):
 		global queue
-		print(f'EasyCoder version {version("easycoder")}')
 		if len(argv) == 0:
 			print('No script supplied')
 			exit()
@@ -387,6 +386,7 @@ class Program:
 
 # This is the program launcher
 def Main():
+	print(f'EasyCoder version {version("easycoder")}')
 	if (len(sys.argv) > 1):
 		Program(sys.argv[1]).start()
 	else:

{easycoder-250107.4 → easycoder-250109.2}/easycoder/ec_renderer.py

@@ -1,23 +1,31 @@
 from kivy.app import App
 from kivy.uix.widget import Widget
+from kivy.graphics import Color, Ellipse, Rectangle
 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
+import math, os
+
+os.environ['KIVY_TEXT'] = 'pango'
 
-# Get a real position or size value
-# These are {n}w/h, where w/h are percentages
+ec_ui = None
+
+def getUI():
+    global ec_ui
+    return ec_ui
+
+# Get an actual screeen position or size value from a specified value
+# such as {n}w/h, where w/h are percentages
 # e.g. 25w or 50h
-def getReal(spec, val):
+def getActual(val, spec=None):
     if isinstance(val, str):
         c = val[-1]
         if c in ['w', 'h']:
             val = int(val[0:len(val)-1])
-            if spec.parent == None:
+            if spec == None or spec.parent == None:
                 if c == 'w':
                     n = Window.width
                 else:
@@ -40,8 +48,8 @@ class Element():
 
     def getRelativePosition(self):
         spec = self.spec
-        x = getReal(spec, spec.pos[0])
-        y = getReal(spec, spec.pos[1])
+        x = getActual(spec.pos[0], spec)
+        y = getActual(spec.pos[1], spec)
         return Vector(x, y)
 
     def getType(self):
@@ -108,10 +116,19 @@ class UI(Widget):
                     Color(c[0], c[1], c[2])
                 else:
                     Color(c[0]/255, c[1]/255, c[2]/255)
-            pos = (getReal(spec, spec.pos[0]), getReal(spec, spec.pos[1]))
-            spec.realpos = pos
-            size = (getReal(spec, spec.size[0]), getReal(spec, spec.size[1]))
+            size = (getActual(spec.size[0], spec), getActual(spec.size[1], spec))
             spec.realsize = size
+            # Deal with special case of 'center'
+            if spec.pos[0] == 'center':
+                left = getActual('50w', spec) - spec.realsize[0]/2
+            else:
+                left = getActual(spec.pos[0], spec)
+            if spec.pos[1] == 'center':
+                bottom = getActual('50h', spec) - spec.realsize[1]/2
+            else:
+                bottom = getActual(spec.pos[1], spec)
+            pos = (left, bottom)
+            spec.realpos = pos
             if spec.parent != None:
                 pos = Vector(pos) + spec.parent.realpos
             if spec.type == 'ellipse':
@@ -128,10 +145,12 @@ class UI(Widget):
                         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')
+                if self.font == None:
+                    label = CoreLabel(text=spec.text, font_size=1000, halign='center', valign='center')
+                else:
+                    label = CoreLabel(text=spec.text, font_context = None, font_name=self.font, font_size=1000, halign='center', valign='center')
                 label.refresh()
-                text = label.texture
-                item = Rectangle(pos=pos, size=size, texture=text)
+                item = Rectangle(pos=pos, size=size, texture=label.texture)
             elif spec.type == 'image':
                 item = AsyncImage(pos=pos, size=size, source=spec.source)
             spec.item = item
@@ -231,9 +250,6 @@ class UI(Widget):
 
 class Renderer(App):
 
-    def getUI(self):
-        return self.ui
-
     def request_close(self):
         print('close window')
         self.kill()
@@ -247,7 +263,9 @@ class Renderer(App):
         return self.ui
 
     def init(self, spec):
-        self.ui = UI()
+        global ec_ui
+        ec_ui = UI()
+        self.ui = ec_ui
         self.title = spec.title
         self.flush = spec.flush
         self.kill = spec.kill

{easycoder-250107.4 → easycoder-250109.2}/easycoder/ec_screenspec.py

@@ -1,21 +1,28 @@
 # screenspec.py
 
 from json import loads
-from .ec_renderer import Object
+from .ec_renderer import Object, getUI
+
+global_id = 0
 
 class ScreenSpec():
 
+    id = 0
+
     # Get an attribute of an element
     def getAttribute(self, id, attribute):
-        element = self.ui.getElement(id)
+        element = getUI().getElement(id)
         return element[attribute]
 
     # Render a single widget
     def createWidget(self, widget, parent):
+        global global_id
         spec = Object()
         type = widget['type']
         spec.type = type
-        spec.id = widget['id']
+        global_id += 1
+        if 'id' in widget: spec.id = widget['id']
+        else: spec.id = f'_{global_id}'
         spec.pos = (widget['left'], widget['bottom'])
         spec.size = (widget['width'], widget['height'])
         if widget.get('fill') != None:
@@ -30,7 +37,7 @@ class ScreenSpec():
             spec.color = widget['color']
         spec.parent = parent
         spec.children = []
-        self.ui.createElement(spec)
+        getUI().createElement(spec)
 
         if '#' in widget:
             children = widget['#']
@@ -51,6 +58,8 @@ class ScreenSpec():
 
     # Render a complete specification
     def renderSpec(self, spec, parent):
+        if 'font' in spec: getUI().font = spec['font']
+        else: getUI().font = None
         widgets = spec['#']
         # If a list, iterate it
         if isinstance(widgets, list):
@@ -61,8 +70,7 @@ class ScreenSpec():
             self.createWidget(spec[widgets], parent)
 
     # Render a graphic specification
-    def render(self, spec, parent, ui):
-        self.ui = ui
+    def render(self, spec, parent):
 
         # If it'a string, process it
         if isinstance(spec, str):
@@ -71,4 +79,3 @@ class ScreenSpec():
         # If it's a 'dict', extract the spec and the args
         else:
             self.renderSpec(spec, parent)
-

{easycoder-250107.4 → easycoder-250109.2}/easycoder/ec_value.py

@@ -1,5 +1,12 @@
 from .ec_classes import FatalError
 
+# Create a constant
+def getConstant(str):
+	value = {}
+	value['type'] = 'text'
+	value['content'] = str
+	return value
+
 class Value:
 
 	def __init__(self, compiler):
@@ -15,7 +22,7 @@ class Value:
 			return None
 
 		value = {}
-			
+
 		if token == 'true':
 			value['type'] = 'boolean'
 			value['content'] = True
@@ -80,7 +87,7 @@ class Value:
 			value = domain.modifyValue(value)
 
 		return value
-	
+
 	def compileConstant(self, token):
 		value = {}
 		if type(token) == 'str':

easycoder-250109.2/plugins/ec_keyboard.py

@@ -0,0 +1,248 @@
+from easycoder import Object, FatalError, RuntimeError
+from easycoder import Handler
+from easycoder import getConstant
+from easycoder.ec_screenspec import ScreenSpec
+from easycoder.ec_renderer import getActual, getUI
+import json
+
+class Keyboard(Handler):
+
+    def __init__(self, compiler):
+        Handler.__init__(self, compiler)
+        self.keyboard = None
+        self.key = None
+        self.onTap = None
+
+    def getName(self):
+        return 'keyboard'
+
+    #############################################################################
+    # Keyword handlers
+
+    # Create a keyboard
+    def k_create(self, command):
+        if self.nextIs('keyboard'):
+            command['template'] = self.nextValue()
+            buttonStyle = 'ellipse'
+            buttonTemplate = None
+            buttonTextWidth = getConstant('50w')
+            buttonTextHeight = getConstant('50h')
+            buttonTextColor = getConstant('black')
+            buttonTextX = getConstant('center')
+            buttonTextY = getConstant('center')
+            buttonColor = getConstant('white')
+            buttonFont = None
+            while True:
+                token = self.peek()
+                if token == 'button':
+                    self.nextToken()
+                    token = self.nextToken()
+                    if token == 'style':
+                        token = self.nextToken()
+                        if token in ['ellipse', 'rectangle', 'image']:
+                            buttonStyle = token
+                        else: RuntimeError(self.program, f'Unknown style \'token\'')
+                    elif token == 'color':
+                        buttonColor = self.nextValue()
+                    elif token == 'font':
+                        buttonFont = self.nextValue()
+                    elif token == 'template':
+                        buttonTemplate = self.nextValue()
+                    elif token == 'text':
+                        token = self.nextToken()
+                        if token =='width':
+                            buttonTextWidth = self.nextValue()
+                        elif token == 'height':
+                            buttonTextHeight = self.nextValue()
+                        elif token == 'color':
+                            buttonTextColor = self.nextValue()
+                        elif token == 'x':
+                            buttonTextX = self.nextValue()
+                        elif token == 'y':
+                            buttonTextY = self.nextValue()
+                        else: RuntimeError(self.program, f'Unknown property \'token\'')
+                else:
+                    break
+            command['button-style'] = buttonStyle
+            command['button-template'] = buttonTemplate
+            command['button-text-width'] = buttonTextWidth
+            command['button-text-height'] = buttonTextHeight
+            command['button-text-color'] = buttonTextColor
+            command['button-text-x'] = buttonTextX
+            command['button-text-y'] = buttonTextY
+            command['button-color'] = buttonColor
+            command['button-font'] = buttonFont
+            self.add(command)
+            return True
+        return False
+
+    def r_create(self, command):
+        self.keyboard = Object()
+        template = self.getRuntimeValue(command['template'])
+        with open(f'{template}') as f: s = f.read()
+        self.keyboard.layout = json.loads(s)
+        self.keyboard.buttonStyle = command['button-style']
+        self.keyboard.buttonTemplate = self.getRuntimeValue(command['button-template'])
+        self.keyboard.buttonTextWidth =  self.getRuntimeValue(command['button-text-width'])
+        self.keyboard.buttonTextHeight =  self.getRuntimeValue(command['button-text-height'])
+        self.keyboard.buttonTextColor =  self.getRuntimeValue(command['button-text-color'])
+        self.keyboard.buttonTextX =  self.getRuntimeValue(command['button-text-x'])
+        self.keyboard.buttonTextY =  self.getRuntimeValue(command['button-text-y'])
+        self.keyboard.buttonColor =  self.getRuntimeValue(command['button-color'])
+        self.keyboard.buttonFont =  self.getRuntimeValue(command['button-font'])
+        return self.nextPC()
+
+    # on click/tap keyboard
+    def k_on(self, command):
+        token = self.nextToken()
+        if token in ['click', 'tap']:
+            if self.nextIs('keyboard'):
+                command['goto'] = self.getPC() + 2
+                self.add(command)
+                self.nextToken()
+                pcNext = self.getPC()
+                cmd = {}
+                cmd['domain'] = 'core'
+                cmd['lino'] = command['lino']
+                cmd['keyword'] = 'gotoPC'
+                cmd['goto'] = 0
+                cmd['debug'] = False
+                self.addCommand(cmd)
+                self.compileOne()
+                cmd = {}
+                cmd['domain'] = 'core'
+                cmd['lino'] = command['lino']
+                cmd['keyword'] = 'stop'
+                cmd['debug'] = False
+                self.addCommand(cmd)
+                # Fixup the link
+                self.getCommandAt(pcNext)['goto'] = self.getPC()
+                return True
+        return False
+
+     # Set a handler
+    def r_on(self, command):
+        self.onTap = command['goto']
+        return self.nextPC()
+
+    # Render a keyboard
+    # render keyboard at {left} {bottom} width {width}
+    def k_render(self, command):
+        if self.nextIs('keyboard'):
+            token = self.peek()
+            while token in ['at', 'width']:
+                    self.nextToken()
+                    if token == 'at':
+                        command['x'] = self.nextValue()
+                        command['y'] = self.nextValue()
+                    elif token == 'width':
+                        command['w'] = self.nextValue()
+                    token = self.peek()
+            self.add(command)
+            return True
+        return False
+
+    def r_render(self, command):
+        x = getActual(self.getRuntimeValue(command['x']))
+        y = getActual(self.getRuntimeValue(command['y']))
+        w = getActual(self.getRuntimeValue(command['w']))
+        # Scan the keyboard layout to find the longest row
+        max = 0
+        nrows = len(self.keyboard.layout)
+        for r in range(0, nrows):
+            row = self.keyboard.layout[r]
+            # Count the number of buttons
+            if len(row) > max: max = len(row)
+        # Divide the keyboard width by the number of buttons to get the button size
+        bs = w / max
+        # Compute the keyboard height
+        h = bs * nrows
+        # Build the spec
+        buttons = []
+        list = []
+        by = y
+        for r in reversed(range(0, nrows)):
+            row = self.keyboard.layout[r]
+            bx = x
+            for b in range(0, len(row)):
+                button = row[b]
+                id = button['id']
+                button['type'] = self.keyboard.buttonStyle
+                button['source'] = self.keyboard.buttonTemplate
+                button['left'] = bx
+                button['bottom'] = by
+                button['width'] = bs
+                button['height'] = bs
+                button['fill'] = self.keyboard.buttonColor
+                label = {}
+                label['type'] = 'text'
+                label['left'] = self.keyboard.buttonTextX
+                label['bottom'] = self.keyboard.buttonTextY
+                label['width'] = self.keyboard.buttonTextWidth
+                label['height'] = self.keyboard.buttonTextHeight
+                label['text'] = id
+                label['color'] = self.keyboard.buttonTextColor
+                button['#'] = 'Label'
+                button['Label'] = label
+                buttons.append(button)
+                list.append(id)
+                bx += bs
+            by += bs
+        spec = {}
+        spec['#'] = list
+        for n in range(0, len(list)):
+            spec[list[n]] = buttons[n]
+
+        spec['font'] = self.keyboard.buttonFont
+        try:
+            ScreenSpec().render(spec, None)
+        except Exception as e:
+            RuntimeError(self.program, e)
+
+        # Add a callback to each button
+        def oncb(id):
+            self.key = id
+            if self.onTap != None:
+                self.program.run(self.onTap)
+        for b in range(0, len(list)):
+            id = list[b]
+            getUI().setOnClick(id, id, oncb)
+
+        return self.nextPC()
+
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
+
+    #############################################################################
+    # Compile a value in this domain
+    def compileValue(self):
+        value = {}
+        value['domain'] = self.getName()
+        if self.tokenIs('the'):
+            self.nextToken()
+        kwd = self.getToken()
+
+        if kwd == 'key':
+            value['type'] = kwd
+            return value
+        return None
+
+    #############################################################################
+    # Value handlers
+
+    def v_key(self, v):
+        value = {}
+        value['type'] = 'text'
+        value['content'] = self.key
+        return value
+
+    #############################################################################
+    # Compile a condition in this domain
+    def compileCondition(self):
+        condition = {}
+        return condition
+
+    #############################################################################
+    # Condition handlers