easycoder 241227.1__tar.gz → 241231.1__tar.gz

{easycoder-241227.1 → easycoder-241231.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: easycoder
-Version: 241227.1
+Version: 241231.1
 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>
@@ -60,9 +60,17 @@ Here in the repository is a folder called `scripts` containing some sample scrip
 `fizzbuzz.ecs` is a simple programming challenge often given at job interviews
 
 ## Graphical programmming
-**_EasyCoder_** is currently being extended to include a graphical programming environment. A single demo script `graphics-demo.ecs` is included in the `scripts` directory. To run it, first install the Python graphics library if it's not already present on your system. On Linux this is done with `sudo apt install python3-tk`. On Windows it's `pip install tk`. Then give the command `easycoder -g scripts/graphics-demo.ecs`.
+**_EasyCoder_** includes a graphical programming environment that is in the early stages of development. A couple of demo scripts are included in the `scripts` directory. To run them, first install the Python `kivy` graphics library if it's not already present on your system. This is done with `pip install kivy`. Then run a script using `easycoder {scriptname}.ecg`.
 
-As development progresses this demo script will be extended to include new features as they are added. **_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs.
+Graphical scripts look much like any other script but their file names must use the extension `.ecg` to signal to **_EasyCoder_** that it needs to load the graphics module. This allows the **_EasyCoder_** application to be used wherever Python is installed, in either a command-line or a graphical environment (but graphics will of course not be available in the former).
+
+A couple of demo scripts are included in the `scripts` directory:
+
+`graphics-demo.ecg` shows some of the elements that can be created, and demonstrates a variety of the graphical features of the language such as detecting when elements are clicked.
+
+`wave.ecg` is a "Mexican Wave" simulation.
+
+**_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs.
 
 ## EasyCoder programming reference
 

{easycoder-241227.1 → easycoder-241231.1}/README.md

@@ -49,9 +49,17 @@ Here in the repository is a folder called `scripts` containing some sample scrip
 `fizzbuzz.ecs` is a simple programming challenge often given at job interviews
 
 ## Graphical programmming
-**_EasyCoder_** is currently being extended to include a graphical programming environment. A single demo script `graphics-demo.ecs` is included in the `scripts` directory. To run it, first install the Python graphics library if it's not already present on your system. On Linux this is done with `sudo apt install python3-tk`. On Windows it's `pip install tk`. Then give the command `easycoder -g scripts/graphics-demo.ecs`.
+**_EasyCoder_** includes a graphical programming environment that is in the early stages of development. A couple of demo scripts are included in the `scripts` directory. To run them, first install the Python `kivy` graphics library if it's not already present on your system. This is done with `pip install kivy`. Then run a script using `easycoder {scriptname}.ecg`.
 
-As development progresses this demo script will be extended to include new features as they are added. **_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs.
+Graphical scripts look much like any other script but their file names must use the extension `.ecg` to signal to **_EasyCoder_** that it needs to load the graphics module. This allows the **_EasyCoder_** application to be used wherever Python is installed, in either a command-line or a graphical environment (but graphics will of course not be available in the former).
+
+A couple of demo scripts are included in the `scripts` directory:
+
+`graphics-demo.ecg` shows some of the elements that can be created, and demonstrates a variety of the graphical features of the language such as detecting when elements are clicked.
+
+`wave.ecg` is a "Mexican Wave" simulation.
+
+**_EasyCoder_** graphics are handled by a library module, `ec_renderer` that can be used outside of the **_EasyCoder_** environment, in other Python programs.
 
 ## EasyCoder programming reference
 

easycoder-241231.1/easycoder/README.md

@@ -0,0 +1,6 @@
+# EasyCode source code
+These are the Python files that comprise **_EasyCoder_**.
+
+**_EasyCoder_** has a small number of third-party dependencies. A minor one is `pytz`, which handles timezones. The biggest one by far is `kivy`, a comprehensive Python graphics library.
+
+If an **_EasyCoder_** script filename ends with `.ecs` it's a command-line script. If it ends with `.ecg` it's a script for a graphical application and will cause `kivy` to be imported. Obviously this will only work on a GUI-based system, whereas command-line scripts will run anywhere there is Python.

{easycoder-241227.1 → easycoder-241231.1}/easycoder/__init__.py

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

{easycoder-241227.1 → easycoder-241231.1}/easycoder/ec_core.py

@@ -696,6 +696,29 @@ class Core(Handler):
         self.putSymbolValue(target, value)
         return self.nextPC()
 
+    # Negate a variable
+    def k_negate(self, command):
+        if self.nextIsSymbol():
+            symbolRecord = self.getSymbolRecord()
+            if symbolRecord['valueHolder']:
+                command['target'] = self.getToken()
+                self.add(command)
+                return True
+            self.warning(f'Core.negate: Variable "{symbolRecord["name"]}" does not hold a value')
+        return False
+
+    def r_negate(self, command):
+        symbolRecord = self.getVariable(command['target'])
+        if not symbolRecord['valueHolder']:
+            RuntimeError(self.program, f'{symbolRecord["name"]} does not hold a value')
+            return None
+        value = self.getSymbolValue(symbolRecord)
+        if value == None:
+            RuntimeError(self.program, f'{symbolRecord["name"]} has not been initialised')
+        value['content'] *= -1
+        self.putSymbolValue(symbolRecord, value)
+        return self.nextPC()
+
     # Define an object variable
     def k_object(self, command):
         return self.compileVariable(command)
@@ -976,7 +999,7 @@ class Core(Handler):
         content = self.getSymbolValue(templateRecord)['content']
         original = self.getRuntimeValue(command['original'])
         replacement = self.getRuntimeValue(command['replacement'])
-        content = content.replace(original, replacement)
+        content = content.replace(original, str(replacement))
         value = {}
         value['type'] = 'text'
         value['numeric'] = False
@@ -1417,7 +1440,7 @@ class Core(Handler):
     # Compile a value in this domain
     def compileValue(self):
         value = {}
-        value['domain'] = 'core'
+        value['domain'] = self.getName()
         token = self.getToken()
         if self.isSymbol():
             value['name'] = token

{easycoder-241227.1 → easycoder-241231.1}/easycoder/ec_graphics.py

@@ -9,7 +9,7 @@ class Graphics(Handler):
         Handler.__init__(self, compiler)
 
     def getName(self):
-        return 'kivy'
+        return 'graphics'
 
     #############################################################################
     # Keyword handlers
@@ -204,12 +204,47 @@ 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()
+            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):
+        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()
         if token in ['click', 'tap']:
@@ -255,37 +290,6 @@ class Graphics(Handler):
                 RuntimeError(self.program, f'{record['name']} is not a clickable object')
         return self.nextPC()
 
-    # move an element
-    def k_move(self, command):
-        if self.nextIsSymbol():
-            record = self.getSymbolRecord()
-            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):
-        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_rectangle(self, command):
         return self.compileVariable(command)
 
@@ -306,13 +310,22 @@ class Graphics(Handler):
 
     def r_render(self, command):
         self.ui = self.renderer.getUI()
-        ScreenSpec().render(self.getRuntimeValue(command['spec']), self.ui)
+        try:
+            ScreenSpec().render(self.getRuntimeValue(command['spec']), self.ui)
+        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)
+            cmd = {}
+            cmd['domain'] = 'graphics'
+            cmd['lino'] = command['lino'] + 1
+            cmd['keyword'] = 'getui'
+            cmd['debug'] = False
+            self.addCommand(cmd)
             return True
         return False
 
@@ -323,6 +336,33 @@ class Graphics(Handler):
         self.program.run(self.nextPC())
         self.renderer.run()
 
+    # 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_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()
+
     #############################################################################
     # Modify a value or leave it unchanged.
     def modifyValue(self, value):
@@ -333,16 +373,24 @@ class Graphics(Handler):
     def compileValue(self):
         value = {}
         value['domain'] = self.getName()
-        if self.tokenIs('attribute'):
+        if self.tokenIs('the'):
+            self.nextToken()
+        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['type'] = 'attribute'
                         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
 
     #############################################################################
@@ -361,6 +409,16 @@ class Graphics(Handler):
         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
     def compileCondition(self):

{easycoder-241227.1 → easycoder-241231.1}/easycoder/ec_program.py

@@ -200,44 +200,60 @@ class Program:
 
 	# Tokenise the script
 	def tokenise(self, script):
-		index = 0
-		lino = 0
-		for line in script.lines:
+		token = ''
+		literal = False
+		for lino in range(0, len(script.lines)):
+			line = script.lines[lino]
 			length = len(line)
-			token = ''
-			inSpace = True
+			if length == 0:
+				continue
+			# Look for the first non-space
 			n = 0
-			while n < length:
+			while n < length and line[n].isspace():
+				n += 1
+			# The whole line may be empty
+			if n == length:
+				if literal:
+					token += '\n'
+				continue
+			# If in an unfinished literal, the first char must be a backtick to continue adding to it
+			if literal:
+				if line[n] != '`':
+					# Close the current token
+					if len(token) > 0:
+						script.tokens.append(Token(lino, token))
+						token = ''
+						literal = False
+				n += 1
+			for n in range(n, length):
 				c = line[n]
-				if len(c.strip()) == 0:
-					if (inSpace):
-						n += 1
+				# Test if we are in a literal
+				if not literal:
+					if c.isspace():
+						if len(token) > 0:
+							script.tokens.append(Token(lino, token))
+							token = ''
 						continue
-					script.tokens.append(Token(lino, token))
-					index += 1
-					token = ''
-					inSpace = True
-					n += 1
-					continue
-				inSpace = False
+					elif c == '!':
+						break
+				# Test for the start or end of a literal
 				if c == '`':
-					m = n
-					n += 1
-					while n < len(line) - 1:
-						if line[n] == '`':
-							break
-						n += 1
-					# n += 1
-					token = line[m:n+1]
-				elif c == '!':
-					break
+					if literal:
+						token += c
+						literal = False
+					else:
+						token += c
+						literal = True
+						m = n
+						continue
 				else:
 					token += c
-				n += 1
 			if len(token) > 0:
-				script.tokens.append(Token(lino, token))
-				index += 1
-			lino += 1
+				if literal:
+					token += '\n'
+				else:
+					script.tokens.append(Token(lino, token))
+					token = ''
 		return
 	
 	def finish(self):

{easycoder-241227.1 → easycoder-241231.1}/easycoder/ec_renderer.py

@@ -24,6 +24,13 @@ class Element():
     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
@@ -32,13 +39,16 @@ class Element():
         return pos
 
     def setPos(self, pos):
-        self.spec.pos = 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.pos) + spec.parent.pos
+        spec.item.pos = Vector(spec.realpos) + spec.parent.realpos
+            
+    def getRealSize(self):
+        return self.spec.realsize
             
     def getSize(self):
         return self.spec.size
@@ -68,6 +78,25 @@ class UI(Widget):
         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
@@ -76,13 +105,16 @@ class UI(Widget):
                     Color(c[0], c[1], c[2])
                 else:
                     Color(c[0]/255, c[1]/255, c[2]/255)
-            pos = spec.pos
+            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.pos
+                pos = Vector(pos) + spec.parent.realpos
             if spec.type == 'ellipse':
-                item = Ellipse(pos=pos, size=spec.size)
+                item = Ellipse(pos=pos, size=size)
             elif spec.type == 'rectangle':
-                item = Rectangle(pos=pos, size=spec.size)
+                item = Rectangle(pos=pos, size=size)
             elif spec.type == 'text':
                 if hasattr(spec, 'color'):
                     c = spec.color
@@ -96,16 +128,16 @@ class UI(Widget):
                 label = CoreLabel(text=spec.text, font_size=1000, halign='center', valign='center')
                 label.refresh()
                 text = label.texture
-                item = Rectangle(pos=spec.pos, size=spec.size, texture=text)
+                item = Rectangle(pos=pos, size=size, texture=text)
             elif spec.type == 'image':
-                item = AsyncImage(pos=spec.pos, size=spec.size, source=spec.source)
+                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.getPos()) + dist)
+            element.setPos(Vector(element.getRealPos()) + dist)
             for id in element.getChildren():
                 self.getElement(id).repos()
         return
@@ -113,7 +145,7 @@ class UI(Widget):
     def moveElementTo(self, id, pos):
         element = self.getElement(id)
         if element != None:
-            self.moveElementBy(id, Vector(pos) - element.getPos())
+            self.moveElementBy(id, Vector(pos) - element.getRealPos())
         return
 
     def on_touch_down(self, touch):
@@ -123,9 +155,9 @@ class UI(Widget):
         for element in reversed(self.zlist):
             if element.cb != None:
                 spec = element.spec
-                pos = spec.pos
+                pos = self.getRealPos()
                 if spec.parent != None:
-                    pos = Vector(pos) + spec.parent.pos
+                    pos = Vector(pos) + spec.parent.getRealPos()
                 size = spec.size
                 if spec.type == 'ellipse':
                     a = size[0]/2
@@ -144,19 +176,47 @@ class UI(Widget):
     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:
+            raise Exception(f'Unknown attribute: {attribute}')
+
     def getAttribute(self, id, attribute):
         spec = self.getElement(id).spec
         if attribute == 'left':
-            return spec.pos[0]
+            return spec.realpos[0]
         elif attribute == 'bottom':
-            return spec.pos[1]
+            return spec.realpos[1]
         elif attribute == 'width':
-            return spec.size[0]
+            return spec.realsize[0]
         elif attribute == 'height':
-            return spec.size[1]
+            return spec.realsize[1]
+        else:
+            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:
             raise Exception(f'Unknown attribute: {attribute}')
-
 
 class Renderer(App):
 
@@ -171,7 +231,7 @@ class Renderer(App):
         self.flush()
     
     def build(self):
-        Clock.schedule_interval(self.flushQueue, 0.05)
+        Clock.schedule_interval(self.flushQueue, 0.01)
         self.ui = UI()
         return self.ui
 

{easycoder-241227.1 → easycoder-241231.1}/easycoder/ec_screenspec.py

@@ -75,4 +75,3 @@ class ScreenSpec():
 
         else:
             raise Exception('Spec is an unknown type')
-

{easycoder-241227.1 → easycoder-241231.1}/json/graphics-demo.json

@@ -1,6 +1,5 @@
 {
     "#": [
-
         "BlackText",
         "Photo",
         "BlueRect",
@@ -8,10 +7,10 @@
     ],
     "BlueRect": {
         "type": "rectangle",
-        "left": 100,
-        "bottom": 100,
-        "width": 100,
-        "height": 100,
+        "left": "30w",
+        "bottom": "15h",
+        "width": "20w",
+        "height": "40h",
         "fill": "blue",
         "id": "bluerect",
         "#": [
@@ -19,10 +18,10 @@
         ],
         "GreenCircle": {
             "type": "ellipse",
-            "left": 20,
-            "bottom": 20,
-            "width": 60,
-            "height": 60,
+            "left": "10w",
+            "bottom": "10h",
+            "width": "80w",
+            "height": "80h",
             "fill": "green",
             "id": "greencircle"
         }
@@ -65,10 +64,10 @@
 
     "Photo": {
         "type": "image",
-        "left": 70,
-        "bottom": 150,
-        "width": 500,
-        "height": 300,
+        "left": "10w",
+        "bottom": "30h",
+        "width": "80w",
+        "height": "60h",
         "source": "images/Semoigo Dawn.jpg",
         "id": "dawn"
     }

easycoder-241231.1/scripts/README.md

@@ -0,0 +1,16 @@
+# EasyCoder example scripts
+The scripts in this folder are as follows:
+
+`hello.ecs` is everybody's first program.
+
+`fizzbuzz.ecs` is often set as a rather trivial programming challenge at job interviews.
+
+`benchmark.ecs` is a program that can be translated into other languages and used to compare runtime performance.
+
+`tests.ecs` is a selection of tests to verify the various language features. It could do with a major expansion to cover more of the language.
+
+`points.ecs` shows how to use a plugin module, in this case one that manages points (pairs of values). This one is aimed at Python programmers wishing to extend the language.
+
+`graphics-demo.ecg` demonstrates various features of the **_EasyCoder_** graphics system. Note that the filename extension is `.ecg` instead of `.ecs`, this being to signal to **_EasyCoder_** that it needs to call in the graphics module.
+
+`wave.ecg` is a simulation of the "Mexican Wave".

easycoder-241231.1/scripts/wave.ecg

@@ -0,0 +1,118 @@
+!   Mexican Wave
+
+    script MexicanWave
+
+    rectangle Bar
+    variable Spec
+    variable Item
+    variable Angle
+    variable Height
+    variable Mid
+    variable Range
+    variable Step
+    variable H
+    variable L
+    variable N
+
+    create window title `Mexican Wave` at 300 300 size 640 480 fill color 255 255 200
+    run graphics
+
+    put `{
+        `   "#": [
+        `       "Bar0",
+        `       "Bar1",
+        `       "Bar2",
+        `       "Bar3",
+        `       "Bar4",
+        `       "Bar5",
+        `       "Bar6",
+        `       "Bar7",
+        `       "Bar8",
+        `       "Bar9"
+        `   ],
+        `
+        `` into Spec
+
+    put 0 into N
+    while N is less than 10
+    begin
+        put `
+        `   "Bar<N>": {
+        `      "type": "rectangle",
+        `      "left": "<L>w",
+        `      "bottom": 0,
+        `      "width": "8w",
+        `      "height": 0,
+        `      "fill": "blue",
+        `      "id": "bar<N>"
+        `   }` into Item
+
+        multiply N by 10 giving L
+        add 1 to L
+        replace `<L>` with L in Item
+        replace `<N>` with N in Item
+        put Spec cat Item into Spec
+        increment N
+        if N is less than 10 put Spec cat `,` cat newline into Spec
+    end
+    put Spec cat newline cat `}` cat newline into Spec
+
+    render Spec
+
+    divide the window height by 2 giving Mid
+    multiply Mid by 9 giving Range
+    divide Range by 10
+
+    set the elements of Bar to 10
+    set the elements of Angle to 10
+    put 0 into N
+    while N is less than 10
+    begin
+        index Bar to N
+        attach Bar to `bar` cat N
+        index Angle to N
+        multiply N by 36 giving Angle
+        increment N
+    end
+
+    wait 1
+    ! Run the setup
+    put 0 into N
+    while N is less than 10
+    begin
+        index Bar to N
+        index Angle to N
+        put sin Angle radius Range into Height
+        negate Height
+        add Mid to Height
+        divide Height by 10 giving Step
+        put 0 into H
+        while H is less than Height
+        begin
+            set attribute `height` of Bar to H
+            add Step to H
+            wait 1 milli
+        end
+        set attribute `height` of Bar to Height
+        increment N
+    end
+
+    wait 2
+    ! Run the main animation
+    while true
+    begin
+        put 0 into N
+        while N is less than 10
+        begin
+            index Bar to N
+            index Angle to N
+            put sin Angle radius Range into Height
+            negate Height
+            add Mid to Height
+            set attribute `height` of Bar to Height
+            if Angle is 0 put 360 into Angle
+            decrement Angle
+            increment N
+        end
+        wait 1 milli
+    end