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

easycoder/ec_graphics.py

@@ -1,6 +1,7 @@
-from .ec_classes import FatalError, RuntimeError
+from .ec_classes import FatalError, RuntimeError, Object
 from .ec_handler import Handler
-from .ec_renderer import *
+from .ec_screenspec import ScreenSpec
+from .ec_renderer import Renderer
 
 class Graphics(Handler):
 
@@ -19,56 +20,183 @@ class Graphics(Handler):
             command['name'] = record['name']
             if self.nextIs('to'):
                 value = self.nextValue()
+                record['id'] = value
                 command['id'] = value
             self.add(command)
         return True
 
     def r_attach(self, command):
-        target = self.getVariable(command['name'])
+        targetRecord = self.getVariable(command['name'])
+        keyword = targetRecord['keyword']
         id = self.getRuntimeValue(command['id'])
-        element = getElement(id)
+        element = self.ui.getElement(id)
         if element == None:
             FatalError(self.program.compiler, f'There is no screen element with id \'{id}\'')
             return -1
-        if element['type'] != target['keyword']:
-            FatalError(self.program.compiler, f'Mismatched element type ({element['type']} and {target['keyword']})')
-        self.putSymbolValue(target, {'type': 'text', 'content': id})
+        if element.getType() != keyword:
+            FatalError(self.program.compiler, f'Mismatched element type ({element['type']} and {keyword})')
+        self.putSymbolValue(targetRecord, {'type': 'text', 'content': id})
         return self.nextPC()
 
+    # close window
     def k_close(self, command):
-        if self.nextIs('screen'):
+        if (self.nextIs('window')):
             self.add(command)
             return True
         return False
 
     def r_close(self, command):
-        closeScreen()
-        return self.nextPC()
+        self.renderer.stop()
+        return 0
 
+    # create window/ellipse/rectangle//text/image
     def k_create(self, command):
-        if self.nextIs('screen'):
+        token = self.nextToken()
+        if (token == 'window'):
+            t = {}
+            t['type'] = 'text'
+            t['content'] = 'EasyCoder'
+            width = self.compileConstant(640)
+            height = self.compileConstant(480)
+            left = self.compileConstant(100)
+            top = self.compileConstant(100)
+            r = self.compileConstant(255)
+            g = self.compileConstant(255)
+            b = self.compileConstant(255)
             while True:
                 token = self.peek()
-                if token == 'at':
+                if token == 'title':
                     self.nextToken()
-                    command['left'] = self.nextValue()
-                    command['top'] = self.nextValue()
+                    t = self.nextValue()
+                elif token == 'at':
+                    self.nextToken()
+                    left = self.nextValue()
+                    top = self.nextValue()
                 elif token == 'size':
                     self.nextToken()
-                    command['width'] = self.nextValue()
-                    command['height'] = self.nextValue()
+                    width = self.nextValue()
+                    height = self.nextValue()
                 elif token == 'fill':
                     self.nextToken()
-                    command['fill'] = self.nextValue()
+                    if self.nextIs('color'):
+                        r = self.nextValue()
+                        g = self.nextValue()
+                        b = self.nextValue()
                 else:
                     break
+            command['type'] = 'window'
+            command['title'] = t
+            command['pos'] = (left, top)
+            command['size'] = (width, height)
+            command['fill'] = (r, g, b)
             self.add(command)
             return True
+        
+        elif self.isSymbol():
+            record = self.getSymbolRecord()
+            command['target'] = record['name']
+            type = record['keyword']
+            command['type'] = type
+            if type in ['ellipse', 'rectangle', 'image']:
+                self.getElementData(type, command)
+                for item in ['width', 'height', 'left', 'bottom', 'r', 'g', 'b']:
+                    if command[item] == None:
+                        FatalError(self.program.compiler, f'Missing property \'{item}\'')
+                return True
+            elif type == 'text':
+                self.getElementData(type, command)
+                for item in ['width', 'height', 'left', 'bottom', 'r', 'g', 'b', 'text']:
+                    if command[item] == None:
+                        FatalError(self.program.compiler, f'Missing property \'{item}\'')
+            self.add(command)
+            record['elementID'] = command['id']
         return False
+    
+    def getElementData(self, type, command):
+        width = None
+        height = None
+        left = None
+        bottom = None
+        r = None
+        g = None
+        b = None
+        text = None
+        source = None
+        id = self.nextValue()
+        while True:
+            token = self.peek()
+            if token == 'size':
+                self.nextToken()
+                width = self.nextValue()
+                height = self.nextValue()
+            elif token == 'at':
+                self.nextToken()
+                left = self.nextValue()
+                bottom = self.nextValue()
+            elif token == 'fill':
+                self.nextToken()
+                r = self.nextValue()
+                g = self.nextValue()
+                b = self.nextValue()
+            elif token == 'text':
+                self.nextToken()
+                text = self.nextValue()
+            elif token == 'source':
+                self.nextToken()
+                source = self.nextValue()
+            else:
+                break
+        command['id'] = id
+        command['type'] = type
+        if width != None:
+            command['width'] = width
+        if height != None:
+            command['height'] = height
+        if left!= None:
+            command['left'] = left
+        if bottom != None:
+            command['bottom'] = bottom
+        if r != None:
+            command['r'] = r
+        if g != None:
+            command['g'] = g
+        if b != None:
+            command['b'] = b
+        if text != None:
+            command['text'] = text
+        if source != None:
+            command['source'] = source
 
     def r_create(self, command):
-        createScreen(command)
+        try:
+            type = command['type']
+            if type == 'window':
+                self.windowSpec = Object()
+                self.windowSpec.title = command['title']['content']
+                self.windowSpec.flush = self.program.flush
+                self.windowSpec.finish = self.program.finish
+                self.windowSpec.pos = (self.getRuntimeValue(command['pos'][0]), self.getRuntimeValue(command['pos'][1]))
+                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)
+            else:
+                element = self.ui.createWidget(self.getWidgetSpec(command))
+                print(element)
+        except Exception as e:
+            RuntimeError(self.program, e)
         return self.nextPC()
+    
+    def getWidgetSpec(self, command):
+        spec = Object()
+        spec.id = self.getRuntimeValue(command['id'])
+        spec.type = command['type']
+        spec.w = self.getRuntimeValue(command['width'])
+        spec.h = self.getRuntimeValue(command['height'])
+        spec.x = self.getRuntimeValue(command['left'])
+        spec.y = self.getRuntimeValue(command['bottom'])
+        spec.r = self.getRuntimeValue(command['r'])/255
+        spec.g = self.getRuntimeValue(command['g'])/255
+        spec.b = self.getRuntimeValue(command['b'])/255
+        return spec
 
     def k_ellipse(self, command):
         return self.compileVariable(command)
@@ -76,75 +204,57 @@ class Graphics(Handler):
     def r_ellipse(self, command):
         return self.nextPC()
 
+    def r_getui(self, command):
+        self.ui = self.renderer.getUI()
+        return self.nextPC()
+
     def k_image(self, command):
         return self.compileVariable(command)
 
     def r_image(self, command):
         return self.nextPC()
 
+    # move an element
     def k_move(self, command):
         if self.nextIsSymbol():
             record = self.getSymbolRecord()
-            if record['keyword'] in ['rectangle', 'ellipse', 'text', 'image']:
-                command['name'] = record['name']
-                if self.nextToken() in ['by', 'to']:
-                    command['type'] = self.getToken()
+            type = record['keyword']
+            if type in ['ellipse', 'rectangle']:
+                command['target'] = record['id']
+                token = self.nextToken()
+                if token == 'to':
                     command['x'] = self.nextValue()
                     command['y'] = self.nextValue()
                     self.add(command)
                     return True
+                elif token == 'by':
+                    command['keyword'] = 'moveBy'
+                    command['dx'] = self.nextValue()
+                    command['dy'] = self.nextValue()
+                    self.add(command)
+                    return True
         return False
 
     def r_move(self, command):
-        target = self.getVariable(command['name'])
-        id = self.getSymbolValue(target)['content']
-        type = command['type']
-        x = self.getRuntimeValue(command['x'])
-        y = self.getRuntimeValue(command['y'])
-        if type == 'by':
-            moveElement(id, x, y)
-        elif type == 'to':
-            moveElementTo(id, x, y)
+        pos = (self.getRuntimeValue(command['x']), self.getRuntimeValue(command['y']))
+        self.ui.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)
         return self.nextPC()
 
     def k_on(self, command):
         token = self.nextToken()
-        command['type'] = token
-        if token == 'click':
-            command['event'] = token
-            if self.peek() == 'in':
-                self.nextToken()
-            if self.nextIs('screen'):
-                command['target'] = None
-            elif self.isSymbol():
+        if token in ['click', 'tap']:
+            command['type'] = 'tap'
+            if self.nextIsSymbol():
                 target = self.getSymbolRecord()
-                command['target'] = target['name']
             else:
                 FatalError(self.program.compiler, f'{self.getToken()} is not a screen element')
                 return False
-            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
-        elif token == 'tick':
-            command['event'] = token
+            command['target'] = target['name']
             command['goto'] = self.getPC() + 2
             self.add(command)
             self.nextToken()
@@ -170,18 +280,14 @@ class Graphics(Handler):
 
     def r_on(self, command):
         pc = command['goto']
-        if command['type'] == 'click':
-            event = command['event']
-            if event == 'click':
-                target = command['target']
-                if target == None:
-                    value = 'screen'
-                else:
-                    widget = self.getVariable(target)
-                value = widget['value'][widget['index']]
-                setOnClick(value['content'], lambda: self.run(pc))
-        elif command['type'] == 'tick':
-            setOnTick(lambda: self.run(pc))
+        if command['type'] == 'tap':
+            record = self.getVariable(command['target'])
+            keyword = record['keyword']
+            if keyword in ['ellipse', 'rectangle', 'text', 'image']:
+                id = record['value'][record['index']]['content']
+                self.ui.setOnClick(id, lambda: self.run(pc))
+            else:
+                RuntimeError(self.program, f'{record['name']} is not a clickable object')
         return self.nextPC()
 
     def k_rectangle(self, command):
@@ -190,181 +296,128 @@ class Graphics(Handler):
     def r_rectangle(self, command):
         return self.nextPC()
 
+    def k_text(self, command):
+        return self.compileVariable(command)
+
+    def r_text(self, command):
+        return self.nextPC()
+
+    # render {spec}
     def k_render(self, command):
-        command['value'] = self.nextValue()
-        command['parent'] = 'screen'
-        if self.peek() == 'in':
-            self.nextToken()
-            if self.nextIsSymbol():
-                record = self.getSymbolRecord()
-                type = record['type']
-                name = record['name']
-                if type in ['rectangle', 'ellipse']:
-                    command['parent'] = record['name']
-                    self.add(command)
-                    return True
-                else:
-                    self.warning(f'Graphics.render: {name} cannot be a parent of another element')
-                    return False
+        command['spec'] = self.nextValue()
         self.add(command)
         return True
-        FatalError(self.program.compiler, 'Nothing specified to render')
-        return False
 
     def r_render(self, command):
-        parent = command['parent']
-        value = self.getRuntimeValue(command['value'])
-        render(value, parent)
+        self.ui = self.renderer.getUI()
+        try:
+            ScreenSpec().render(self.getRuntimeValue(command['spec']), self.ui)
+        except Exception as e:
+            RuntimeError(self.program, e)
         return self.nextPC()
 
-    def k_set(self, command):
-        if self.peek() == 'the':
-            self.nextToken()
-        token = self.peek()
-        if token == 'text':
-            self.nextToken()
-            command['variant'] = 'setText'
-            if self.peek() == 'of':
-                self.nextToken()
-            if self.nextIsSymbol():
-                record = self.getSymbolRecord()
-                command['name'] = record['name']
-                if record['keyword'] != 'text':
-                    RuntimeError(command['program'], f'Symbol type is not \'text\'')
-                if self.peek() == 'to':
-                    self.nextToken()
-                    command['value'] = self.nextValue()
-                    self.add(command)
-                    return True
-            return False
-        elif token == 'background':
-            self.nextToken()
-            command['variant'] = 'setBackground'
-            if self.peek() == 'color':
-                self.nextToken()
-            if self.peek() == 'of':
-                self.nextToken()
-            if self.nextIsSymbol():
-                record = self.getSymbolRecord()
-                command['name'] = record['name']
-                if not record['keyword'] in ['rectangle', 'ellipse']:
-                    RuntimeError(command['program'], f'Symbol type is not \'rectangle\' or \'ellipse\'')
-                if self.peek() == 'to':
-                    self.nextToken()
-                    command['value'] = self.nextValue()
-                    self.add(command)
-                return True
-            return False
-        return False
-
-    def r_set(self, command):
-        variant = command['variant']
-        if variant == 'setText':
-            variable = self.getVariable(command['name'])
-            element = self.getSymbolValue(variable)
-            value = self.getRuntimeValue(command['value'])
-            setText(element['content'], value)
-        elif variant == 'setBackground':
-            variable = self.getVariable(command['name'])
-            element = self.getSymbolValue(variable)
-            value = self.getRuntimeValue(command['value'])
-            setBackground(element['content'], value)
-        return self.nextPC()
-
-    def k_show(self, command):
-        if self.nextIs('screen'):
-            command['name'] = None
+    # run graphics
+    def k_run(self, command):
+        if self.nextIs('graphics'):
             self.add(command)
+            cmd = {}
+            cmd['domain'] = 'graphics'
+            cmd['lino'] = command['lino'] + 1
+            cmd['keyword'] = 'getui'
+            cmd['debug'] = False
+            self.addCommand(cmd)
             return True
         return False
 
-    def r_show(self, command):
-        showScreen()
-        return self.nextPC()
+    def r_run(self, command):
+        self.renderer = Renderer()
+        self.renderer.init(self.windowSpec)
+        self.program.setExternalControl()
+        self.program.run(self.nextPC())
+        self.renderer.run()
 
-    def k_spec(self, command):
-        return self.compileVariable(command, True)
+    # Set something
+    def k_set(self, command):
+        if self.nextIs('attribute'):
+            command['attribute'] = self.nextValue()
+            if self.nextIs('of'):
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    if record['keyword'] in ['ellipse', 'rectangle', 'text', 'image']:
+                        command['target'] = record['name']
+                        if self.nextIs('to'):
+                            command['value'] = self.nextValue()
+                            self.addCommand(command)
+                            return True
+                    else:
+                        FatalError(self.program.compiler, f'Invalid type: {record['keyword']}')
+                else:
+                    FatalError(self.program.compiler, f'\'{self.getToken()}\' is not a variable')
+        return False
 
-    def r_spec(self, command):
+    def r_set(self, command):
+        attribute = self.getRuntimeValue(command['attribute'])
+        target = self.getVariable(command['target'])
+        id = target['value'][target['index']]['content']
+        value = self.getRuntimeValue(command['value'])
+        self.ui.setAttribute(id, attribute, value)
         return self.nextPC()
 
-    def k_text(self, command):
-        return self.compileVariable(command)
+    #############################################################################
+    # Modify a value or leave it unchanged.
+    def modifyValue(self, value):
+        return value
 
-    def r_text(self, command):
-        return self.nextPC()
-    
     #############################################################################
     # Compile a value in this domain
     def compileValue(self):
         value = {}
-        value['domain'] = 'graphics'
-        token = self.getToken()
-        if self.isSymbol():
-            value['name'] = token
-            symbolRecord = self.getSymbolRecord()
-            keyword = symbolRecord['keyword']
-            if keyword == 'module':
-                value['type'] = 'module'
-                return value
-
-            if symbolRecord['valueHolder'] == True or keyword == 'dictionary':
-                value['type'] = 'symbol'
-                return value
-            return None
-
+        value['domain'] = self.getName()
         if self.tokenIs('the'):
             self.nextToken()
-        token = self.getToken()
-
-        value['type'] = token
-
-        if token == 'color':
-            name = self.nextToken()
-            value = {}
-            value['type'] = 'string'
-            value['content'] = name
-            return value
-        
-        elif token == 'attribute':
-            value['attribute'] = self.nextValue()
-            if (self.nextIs('of')):
-                if (self.nextIsSymbol()):
-                    value['name'] = self.getToken()
-                    return value
+        kwd = self.getToken()
+        value['type'] = kwd
+        if kwd == 'attribute':
+            attribute = self.nextValue()
+            if self.nextIs('of'):
+                if self.nextIsSymbol():
+                    record = self.getSymbolRecord()
+                    if record['keyword'] in ['ellipse', 'rectangle']:
+                        value['attribute'] = attribute
+                        value['target'] = record['name']
+                        return value
+        elif kwd == 'window':
+            attribute = self.nextToken()
+            if attribute in ['left', 'top', 'width', 'height']:
+                value['attribute'] = attribute
+                return value
         return None
 
-    #############################################################################
-    # Modify a value or leave it unchanged.
-    def modifyValue(self, value):
-        return value
-
     #############################################################################
     # Value handlers
 
-    def v_symbol(self, symbolRecord):
-        result = {}
-        if symbolRecord['valueHolder']:
-            symbolValue = self.getSymbolValue(symbolRecord)
-            if symbolValue == None:
-                return None
-            result['type'] = symbolValue['type']
-            content = symbolValue['content']
-            if content == None:
-                return ''
-            result['content'] = content
-            return result
-        else:
-            return ''
-    
     def v_attribute(self, v):
-        target = self.getVariable(v['name'])
-        attribute = self.getRuntimeValue(v['attribute'])
-        name = target['value'][target['index']]['content']
-        value = {}
-        value['type'] = 'int'
-        value['content'] = getAttribute(name, attribute)
-        return value
+        try:
+            attribute = self.getRuntimeValue(v['attribute'])
+            target = self.getVariable(v['target'])
+            val = self.getSymbolValue(target)
+            v = self.ui.getAttribute(val['content'], attribute)
+            value = {}
+            value['type'] = 'int'
+            value['content'] = int(round(v))
+            return value
+        except Exception as e:
+            RuntimeError(self.program, e)
+
+    def v_window(self, v):
+        try:
+            attribute = v['attribute']
+            value = {}
+            value['type'] = 'int'
+            value['content'] = int(round(self.ui.getWindowAttribute(attribute)))
+            return value
+        except Exception as e:
+            RuntimeError(self.program, e)
 
     #############################################################################
     # Compile a condition

easycoder/ec_handler.py

@@ -25,6 +25,7 @@ class Handler:
 		self.getCommandAt = compiler.getCommandAt
 		self.compileOne = compiler.compileOne
 		self.compileFromHere = compiler.compileFromHere
+		self.compileConstant = compiler.compileConstant
 
 		self.code = self.program.code
 		self.add = self.program.add