easycoder 250527.1__py2.py3-none-any.whl → 250605.1__py2.py3-none-any.whl

easycoder/__init__.py

@@ -9,4 +9,4 @@ from .ec_program import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "250527.1"
+__version__ = "250605.1"

easycoder/ec_program.py

@@ -24,9 +24,6 @@ class Program:
 			exit()
 		self.classes=[Core]
 		scriptName = argv
-		if scriptName.endswith('.ecg'):
-			from .ec_graphics import Graphics
-			self.classes.append(Graphics)
 
 		f = open(scriptName, 'r')
 		source = f.read()
@@ -52,6 +49,11 @@ class Program:
 		self.ticker = 0
 		self.running = True
 
+	# This is called at 10msec intervals by the GUI code
+	def flushCB(self):
+		self.ticker += 1
+		flush()
+
 	def start(self, parent=None, module = None, exports=[]):
 		self.parent = parent
 		self.exports = exports
@@ -289,11 +291,6 @@ class Program:
 			self.parent.waiting = False
 			self.parent.program.run(self.parent.pc)
 
-	# This is called at 10msec intervals by the GUI code
-	def flushCB(self):
-		self.ticker += 1
-		flush()
-
 	# Flush the queue
 	def flush(self, pc):
 		global queue
@@ -326,7 +323,7 @@ class Program:
 					elif self.pc == None or self.pc == 0 or self.pc >= len(self.code):
 						break
 
-	# Run the script
+	# Run the script at a given PC value
 	def run(self, pc):
 		global queue
 		item = Object()

easycoder/ec_pyside.py

@@ -40,12 +40,16 @@ class Graphics(Handler):
     def __init__(self, compiler):
         Handler.__init__(self, compiler)
         self.blocked = False
+        self.runOnTick = 0
 
     def getName(self):
         return 'graphics'
 
     def closeEvent(self):
         print('window closed')
+    
+    def isWidget(self, keyword):
+        return keyword in ['layout', 'groupbox', 'label', 'pushbutton', 'checkbox', 'lineinput', 'listbox', 'combobox']
 
     #############################################################################
     # Keyword handlers
@@ -84,7 +88,7 @@ class Graphics(Handler):
         elif self.isSymbol():
             record = self.getSymbolRecord()
             if record['extra'] == 'gui':
-                if record['keyword'] in ['layout', 'groupbox', 'label', 'pushbutton', 'checkbox', 'lineinput', 'listbox', 'combobox']:
+                if self.isWidget(record['keyword']):
                     if self.peek() == 'to':
                         # (2)
                         record = self.getSymbolRecord()
@@ -170,9 +174,11 @@ class Graphics(Handler):
     # clear {widget}
     def k_clear(self, command):
         if self.nextIsSymbol():
-            command['name'] = self.getSymbolRecord()['name']
-            self.add(command)
-            return True
+            record = self.getSymbolRecord()
+            if self.isWidget(record['keyword']):
+                command['name'] = record['name']
+                self.add(command)
+                return True
         return False
     
     def r_clear(self, command):
@@ -583,9 +589,9 @@ class Graphics(Handler):
 
     # on click {pushbutton}
     # on select {combobox}/{listbox}
+    # on tick
     def k_on(self, command):
         def setupOn():
-            command['name'] = record['name']
             command['goto'] = self.getPC() + 2
             self.add(command)
             self.nextToken()
@@ -606,34 +612,65 @@ class Graphics(Handler):
             cmd['keyword'] = 'stop'
             cmd['debug'] = False
             self.addCommand(cmd)
-            # Fixup the link
+            # Fixup the goto
             self.getCommandAt(pcNext)['goto'] = self.getPC()
 
         token = self.nextToken()
+        command['type'] = token
         if token == 'click':
             if self.nextIsSymbol():
                 record = self.getSymbolRecord()
                 if record['keyword'] == 'pushbutton':
+                    command['name'] = record['name']
                     setupOn()
                     return True
         elif token == 'select':
             if self.nextIsSymbol():
                 record = self.getSymbolRecord()
                 if record['keyword'] in ['combobox', 'listbox']:
+                    command['name'] = record['name']
                     setupOn()
                     return True
+        elif token == 'tick':
+            command['tick'] = True
+            command['runOnTick'] = self.getPC() + 2
+            self.addCommand(command)
+            self.nextToken()
+            # Step over the on tick action
+            pcNext = self.getPC()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'gotoPC'
+            cmd['goto'] = 0
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # This is the on tick handler
+            self.compileOne()
+            cmd = {}
+            cmd['domain'] = 'core'
+            cmd['lino'] = command['lino']
+            cmd['keyword'] = 'stop'
+            cmd['debug'] = False
+            self.addCommand(cmd)
+            # Fixup the goto
+            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            return True
         return False
     
     def r_on(self, command):
-        record = self.getVariable(command['name'])
-        widget = record['widget']
-        keyword = record['keyword']
-        if keyword == 'pushbutton':
-            widget.clicked.connect(lambda: self.run(command['goto']))
-        elif keyword == 'combobox':
-            widget.currentIndexChanged.connect(lambda: self.run(command['goto']))
-        elif keyword == 'listbox':
-            widget.itemClicked.connect(lambda: self.run(command['goto']))
+        if command['type'] == 'tick':
+            self.runOnTick = command['runOnTick']
+        else:
+            record = self.getVariable(command['name'])
+            widget = record['widget']
+            keyword = record['keyword']
+            if keyword == 'pushbutton':
+                widget.clicked.connect(lambda: self.run(command['goto']))
+            elif keyword == 'combobox':
+                widget.currentIndexChanged.connect(lambda: self.run(command['goto']))
+            elif keyword == 'listbox':
+                widget.itemClicked.connect(lambda: self.run(command['goto']))
         return self.nextPC()
 
     # Declare a pushbutton variable
@@ -915,7 +952,10 @@ class Graphics(Handler):
         def init():
             self.program.flush(self.nextPC())
         def flush():
-            if not self.blocked: self.program.flushCB()
+            if not self.blocked:
+                if self.runOnTick != 0:
+                    self.program.run(self.runOnTick)
+                self.program.flushCB()
         timer = QTimer()
         timer.timeout.connect(flush)
         timer.start(10)
@@ -937,10 +977,12 @@ class Graphics(Handler):
         value['domain'] = self.getName()
         token = self.getToken()
         if self.isSymbol():
-            if self.getSymbolRecord()['extra'] == 'gui':
-                value['name'] = token
-                value['type'] = 'symbol'
-                return value
+            record = self.getSymbolRecord()
+            if record['extra'] == 'gui':
+                if self.isWidget(record['keyword']):
+                    value['name'] = token
+                    value['type'] = 'symbol'
+                    return value
 
         else:
             if self.tokenIs('the'): token = self.nextToken()

{easycoder-250527.1.dist-info → easycoder-250605.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: easycoder
-Version: 250527.1
+Version: 250605.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>

{easycoder-250527.1.dist-info → easycoder-250605.1.dist-info}/RECORD

@@ -1,18 +1,16 @@
 easycoder/README.md,sha256=BVXmYphcTJ6q6RN_9L6HtQukgCnOjSLVIsTM3lk-9aM,587
-easycoder/__init__.py,sha256=n1oZv4H492PIeQY3wvjgafh-O6BJs1gYTv4AGgSsTU8,262
+easycoder/__init__.py,sha256=lb5JT5maNx9Zk-n7sDj2xIP5A8_oG_anattp8FiBh7E,262
 easycoder/ec_classes.py,sha256=L6-6yWHDHw8yF9TGL4WWc4p1aUyXzYz6Gom7jJ43h8o,1823
 easycoder/ec_compiler.py,sha256=zKZXXUrQyHbwZ1gJARnwfdAPHWTARa5SN9Y31iuty8o,5086
 easycoder/ec_condition.py,sha256=YXvSBQKEzKGCcgUGo3Qp8iHolXmm2BpEm0NimSDszIM,785
 easycoder/ec_core.py,sha256=IH7lvxr1ZSFcZvd00RV8wzG_fvWX8bSW4YHKLOL3m04,92443
-easycoder/ec_graphics.py,sha256=WXxKMB4GJSmxvk-FVbOTyufiUx4TYIzyDoB1PCAO3JY,16067
-easycoder/ec_gutils.py,sha256=yqu4RRQ6VdRkC5B2ADBYsXzgNu76dLnekd9aUjdEgPw,6399
 easycoder/ec_handler.py,sha256=zPDZ_hqdgNnkCd8B5HmSLkqsGgf4aDmqcUBOPHgo47U,2305
-easycoder/ec_program.py,sha256=ww1SbzWVoQrImt4S648vSPjsWHgjBNAzxIvAIXJ5074,10178
-easycoder/ec_pyside.py,sha256=7mqpZrZIyTL5l3CcY0rqcKcTaEW98ttVyBKaVkwXA40,38389
+easycoder/ec_program.py,sha256=HnJJhd0umQyw8CwUv3wxwG73DFLxciGTry8b3tYG-6w,10094
+easycoder/ec_pyside.py,sha256=I1y8QZgMHLWWxWbKLm_JzHJo6bwASak7tdnuAcuh66c,39904
 easycoder/ec_timestamp.py,sha256=myQnnF-mT31_1dpQKv2VEAu4BCcbypvMdzq7_DUi1xc,277
 easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
-easycoder-250527.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-250527.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-250527.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
-easycoder-250527.1.dist-info/METADATA,sha256=699sqDp-Z8RoULy6ObRZIUHHEBT5gYt2plP-g5fiILc,6829
-easycoder-250527.1.dist-info/RECORD,,
+easycoder-250605.1.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-250605.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-250605.1.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
+easycoder-250605.1.dist-info/METADATA,sha256=j5cFgvwTktuTMUMNYCJuznEQOwnDlhxgB7qXofGdhs4,6829
+easycoder-250605.1.dist-info/RECORD,,

easycoder/ec_graphics.py

@@ -1,429 +0,0 @@
-from .ec_classes import FatalError, RuntimeError
-from .ec_handler import Handler
-from .ec_gutils import GUtils
-import PySimpleGUI as psg
-import json
-from copy import deepcopy
-
-class Graphics(Handler):
-
-    def __init__(self, compiler):
-        Handler.__init__(self, compiler)
-        self.utils = GUtils()
-
-    def getName(self):
-        return 'graphics'
-
-    #############################################################################
-    # Keyword handlers
-
-    def k_add(self, command):
-        token = self.nextToken()
-        if self.isSymbol():
-            symbolRecord = self.getSymbolRecord()
-            name = symbolRecord['name']
-            keyword = symbolRecord['keyword']
-            if keyword == 'layout':
-                command['args'] = name
-            elif keyword in ['column', 'frame', 'tab']:
-                command['name'] = name
-                command['type'] = token
-                if self.peek() == 'to':
-                    command['args'] = name
-                else:
-                    command['args'] = self.utils.getArgs(self)
-        else:
-            command['type'] = token
-            command['args'] = self.utils.getArgs(self)
-        if self.nextIs('to'):
-            if self.nextIsSymbol():
-                symbolRecord = self.getSymbolRecord()
-                if symbolRecord['keyword'] in ['column', 'frame', 'layout', 'tab']:
-                    command['target'] = symbolRecord['name']
-                    self.addCommand(command)
-                    return True
-        return False
-
-    def r_add(self, command):
-        def create(type, layout, args2, target):
-            args = self.utils.getDefaultArgs(type)
-            for n in range(0, len(args2)):
-                try:
-                    self.utils.decode(self, args, args2[n])
-                except Exception as e:
-                    RuntimeError(self.program, e)
-            item = self.utils.createWidget(type, layout, args)
-            target['layout'].append(item)
-
-        target = self.getVariable(command['target'])
-        type = command['type']
-        args = command['args']
-        if not 'layout' in target:
-            target['layout'] = []
-        if len(args) > 0 and args[0] == '{':
-            args = json.loads(self.getRuntimeValue(json.loads(args)))
-            if type in ['Column', 'Frame', 'Tab']:
-                record = self.getVariable(command['name'])
-                layout = record['layout']
-                create(type, layout, args, target)
-            else:
-                create(type, None, args, target)
-        else:
-            if type in ['Column', 'Frame', 'Tab']:
-                record = self.getVariable(command['name'])
-                layout = record['layout']
-                create(type, layout, args, target)
-            else:
-               v = self.getVariable(args)
-               target['layout'].append(v['layout'])
-        return self.nextPC()
-
-    def k_close(self, command):
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['keyword'] == 'window':
-                command['target'] = symbolRecord['name']
-                self.add(command)
-                return True
-        return False
-
-    def r_close(self, command):
-        target = self.getVariable(command['target'])
-        target['window'].close()
-        return self.nextPC()
-
-    def k_column(self, command):
-        return self.compileVariable(command)
-
-    def r_column(self, command):
-        return self.nextPC()
-
-    # create layout {name} from {spec}
-    # create {window} layout {layout}
-    def k_create(self, command):
-        token = self.nextToken()
-        if token == 'layout':
-            if self.nextIsSymbol():
-                record = self.getSymbolRecord()
-                if record['keyword'] == 'layout':
-                    command['layout'] = record['name']
-                    if self.nextIs('from'):
-                        command['spec'] = self.nextValue()
-                        self.addCommand(command)
-                        return True
-        elif self.isSymbol():
-            symbolRecord = self.getSymbolRecord()
-            command['name'] = symbolRecord['name']
-            command['title'] = self.nextValue()
-            if self.nextIs('layout'):
-                if self.nextIsSymbol():
-                    symbolRecord = self.getSymbolRecord()
-                    if symbolRecord['keyword'] == 'layout':
-                        command['layout'] = symbolRecord['name']
-                        self.addCommand(command)
-                        return True
-        return False
-
-    def r_create(self, command):
-        def processItem(name, item):
-            print(name, item['type'])
-            children = item['#']
-            if isinstance(children, list):
-                print("List")
-                for child in children:
-                    print(child)
-            else:
-                print("Single:", children)
-
-        if 'spec' in command:
-            spec = self.getRuntimeValue(command['spec'])
-            layout = self.getVariable(command['layout'])
-            for key in spec.keys():
-                item = spec[key]
-                print(key, item['type'])
-                if item['type'] == 'column':
-                    for child in item['#']: processItem(child, item[child])
-            return self.nextPC()
-        else:
-            record = self.getVariable(command['name'])
-            title = self.getRuntimeValue(command['title'])
-            layout = self.getVariable(command['layout'])['layout']
-            window = psg.Window(title, layout, finalize=True)
-            record['window'] = window
-            record['eventHandlers'] = {}
-            self.program.run(self.nextPC())
-            self.mainLoop(record)
-            return 0
-
-    def k_frame(self, command):
-        return self.compileVariable(command)
-
-    def r_frame(self, command):
-        return self.nextPC()
-
-    # get {variable} from popup {type} {message} {title}
-    def k_get(self, command):
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['hasValue']:
-                command['target'] = self.getToken()
-            else:
-                FatalError(self.compiler, f'Variable "{symbolRecord["name"]}" does not hold a value')
-            if symbolRecord['hasValue']:
-                if self.nextIs('from'):
-                    if self.nextIs('popup'):
-                        command['ptype'] = self.nextToken()
-                        command['message'] = self.nextValue()
-                        command['title'] = self.nextValue()
-                        self.addCommand(command)
-                        return True
-        return False
-
-    def r_get(self, command):
-        target = self.getVariable(command['target'])
-        ptype = command['ptype']
-        if ptype == 'text':
-            text = psg.popup_get_text(self.getRuntimeValue(command['message']), title=self.getRuntimeValue(command['title']))
-        elif ptype == 'ok-cancel':
-            text = psg.popup_ok_cancel(self.getRuntimeValue(command['message']), title=self.getRuntimeValue(command['title']))
-        elif ptype == 'yes-no':
-            text = psg.popup_yes_no(self.getRuntimeValue(command['message']), title=self.getRuntimeValue(command['title']))
-        else:
-            return None
-        v = {}
-        v['type'] = 'text'
-        v['content'] = text
-        self.program.putSymbolValue(target, v)
-        return self.nextPC()
-
-    def k_init(self, command):
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['keyword'] in ['column', 'frame', 'layout', 'tab']:
-                command['target'] = symbolRecord['name']
-                self.add(command)
-                return True
-        return False
-
-    def r_init(self, command):
-        target = self.getVariable(command['target'])
-        target['layout'] = []
-        return self.nextPC()
-
-    def k_layout(self, command):
-        return self.compileVariable(command)
-
-    def r_layout(self, command):
-        return self.nextPC()
-
-    def k_on(self, command):
-        token = self.nextToken()
-        if token == 'event':
-            command['key'] = self.nextValue()
-            if self.nextIs('in'):
-                if self.nextIsSymbol():
-                    record = self.getSymbolRecord()
-                    if record['keyword'] == 'window':
-                        command['window'] = record['name']
-                        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
-
-    def r_on(self, command):
-        key = self.getRuntimeValue(command['key'])
-        window = self.getVariable(command['window'])
-        window['eventHandlers'][key] = lambda: self.run(command['goto'])
-        return self.nextPC()
-
-    # popup {message} {title}
-    def k_popup(self, command):
-        command['message'] = self.nextValue()
-        command['title'] = self.nextValue()
-        self.addCommand(command)
-        return True
-
-    def r_popup(self, command):
-        psg.popup(self.getRuntimeValue(command['message']), title=self.getRuntimeValue(command['title']))
-        return self.nextPC()
-
-    def k_refresh(self, command):
-        if self.nextIsSymbol():
-            symbolRecord = self.getSymbolRecord()
-            if symbolRecord['keyword'] == 'window':
-                command['target'] = symbolRecord['name']
-                self.add(command)
-                return True
-        return False
-
-    def r_refresh(self, command):
-        target = self.getVariable(command['target'])
-        target['window'].refresh()
-        return self.nextPC()
-
-    # set property {property} of {key} in {window} to {value}
-    def k_set(self, command):
-        if self.nextIs('property'):
-            command['property'] = self.nextValue()
-            if self.nextIs('of'):
-                command['key'] = self.nextValue()
-                if self.nextIs('in'):
-                    if self.nextIsSymbol():
-                        record = self.getSymbolRecord()
-                        if record['keyword'] == 'window':
-                            name = record['name']
-                            command['window'] = name
-                            if self.nextIs('to'):
-                                command['value'] = self.nextValue()
-                                self.add(command)
-                            return True
-                        else: RuntimeError(self.program, f'\'{name}\' is not a window variable')
-                    else: RuntimeError(self.program, 'No window variable given')
-        return False
-
-    def r_set(self, command):
-        property = self.getRuntimeValue(command['property'])
-        key = self.getRuntimeValue(command['key'])
-        windowRecord = self.getVariable(command['window'])
-        window = windowRecord['window']
-        value = self.getRuntimeValue(command['value'])
-        self.utils.updateProperty(window[key], property, value)
-        return self.nextPC()
-
-    def k_window(self, command):
-        return self.compileVariable(command)
-
-    def r_window(self, command):
-        return self.nextPC()
-
-    #############################################################################
-    # Compile a value in this domain
-    def compileValue(self):
-        value = {}
-        value['domain'] = self.getName()
-        token = self.getToken()
-        if self.isSymbol():
-            value['name'] = token
-            symbolRecord = self.getSymbolRecord()
-            keyword = symbolRecord['keyword']
-            if keyword == 'event':
-                value['type'] = 'symbol'
-                return value
-            return None
-
-        if self.getToken() == 'the':
-            self.nextToken()
-
-        token = self.getToken()
-        value['type'] = token
-
-        if token == 'event':
-           return value
-
-        if token == 'property':
-            value['property'] = self.nextValue()
-            if self.nextIs('of'):
-                if self.nextToken() == 'the':
-                    if self.nextIs('event'):
-                        return value
-            return None
-
-        if token == 'value':
-            if self.nextIs('of'):
-                if self.nextIs('key'):
-                    value['key'] = self.nextValue()
-                    if self.nextIs('in'):
-                        if self.nextIsSymbol():
-                            record = self.getSymbolRecord()
-                            if record['keyword'] == 'window':
-                                value['window'] = record['name']
-                                return value
-            return None
-
-    #############################################################################
-    # Modify a value or leave it unchanged.
-    def modifyValue(self, value):
-        return value
-
-    #############################################################################
-    # Value handlers
-
-    # This is used by the expression evaluator to get the value of a symbol
-    def v_symbol(self, symbolRecord):
-        if symbolRecord['keyword'] == 'event':
-            return self.getSymbolValue(symbolRecord)
-        else:
-            return None
-
-    def v_event(self, v):
-        window = self.eventValues['window']
-        values = self.eventValues['values']
-        self.utils.getEventProperties(window, values)
-        v['type'] = 'text'
-        v['content'] = values
-        return v
-
-    def v_property(self, v):
-        property = self.getRuntimeValue(v['property'])
-        window = self.eventValues['window']
-        values = self.eventValues['values']
-        self.utils.getEventProperties(window, values)
-        v['type'] = 'text'
-        v['content'] = values[property]
-        return v
-
-    def v_value(self, v):
-        key = self.getRuntimeValue(v['key'])
-        window = self.getVariable(v['window'])
-        value = self.utils.getWidgetValue(window, key)
-        if value == None: RuntimeError(self.program, 'getWidgetValue: unimplemented widget type')
-        v = deepcopy(v)
-        v['type'] = 'text'
-        v['content'] = value
-        return v
-
-    #############################################################################
-    # Compile a condition
-    def compileCondition(self):
-        condition = {}
-        return condition
-
-    #############################################################################
-    # Condition handlers
-
-    #############################################################################
-    # The main loop
-    def mainLoop(self, windowRecord):
-        window = windowRecord['window']
-        eventHandlers = windowRecord['eventHandlers']
-        while True:
-            event, values = window.Read(timeout=100)
-            if event == psg.WIN_CLOSED or event == "EXIT":
-                del window
-                break
-            if event == '__TIMEOUT__': self.program.flushCB()
-            else:
-                if event in eventHandlers:
-                    self.eventValues = {}
-                    self.eventValues['values'] = values
-                    self.eventValues['window'] = window
-                    eventHandlers[event]()
-                    pass

easycoder/ec_gutils.py

@@ -1,175 +0,0 @@
-import PySimpleGUI as psg
-import json
-
-class GUtils:
-
-    # Parse a set of compile-time arguments
-    def getArgs(self, handler):
-        args = []
-        while True:
-            key = handler.nextToken()
-            value = handler.nextValue()
-            value = json.dumps(value)
-            args.append(f'{key}={value}')
-            if handler.peek() == 'and':
-                handler.nextToken()
-            else: break
-        v = {}
-        v['type'] = 'text'
-        v['content'] = json.dumps(args)
-        return json.dumps(v)
-
-    # Get the default args for a graphic element
-    def getDefaultArgs(self, type):
-        args = {}
-        if type == 'Button': self.getDefaultButton(args)
-        elif type == 'Checkbox': self.getDefaultCheckbox(args)
-        elif type == 'Column': self.getDefaultColumn(args)
-        elif type == 'Frame': self.getDefaultFrame(args)
-        elif type == 'Input': self.getDefaultInput(args)
-        elif type == 'Listbox': self.getDefaultListbox(args)
-        elif type == 'Multiline': self.getDefaultMultiline(args)
-        elif type == 'Text': self.getDefaultText(args)
-        return args
-
-    # Decode an argument at runtime
-    def decode(self, handler, args, text):
-        p = text.find('=')
-        if p > 0:
-            key = text[0:p]
-            value = text[p+1:]
-            value = json.loads(value)
-            if value['type'] == 'symbol':
-                record = handler.program.getSymbolRecord(value['name'])
-                value = handler.getSymbolValue(record)
-            if value != None: value = value['content']
-            else: raise Exception('Variable has no value')
-            args[key] = value
-
-    # Reduce the event properties to a list of strings
-    def getEventProperties(self, window, values):
-        keys = values.keys()
-        for key in keys:
-            v = values[key]
-            widget = window.key_dict[key]
-            if type(widget) is psg.Listbox:
-                # Only pick one from those selected
-                v = v[0]
-            values[key] = v
-
-    # Create a widget
-    def createWidget(self, type, layout, args):
-        if type == 'Button': return self.createButton(layout, args)
-        elif type == 'Checkbox': return self.createCheckbox(layout, args)
-        elif type == 'Column': return self.createColumn(layout, args)
-        elif type == 'Frame': return self.createFrame(layout, args)
-        elif type == 'Input': return self.createInput(layout, args)
-        elif type == 'Listbox': return self.createListbox(layout, args)
-        elif type == 'Multiline': return self.createMultiline(layout, args)
-        elif type == 'Text': return self.createText(layout, args)
-        else: return None
-
-    # Get the current value of a widget
-    def getWidgetValue(self, window, key):
-        key_dict = window['window'].key_dict
-        widget = key_dict[key]
-        if type(widget) is psg.Button: return widget.get()
-        elif type(widget) is psg.Checkbox: return widget.get()
-        elif type(widget) is psg.Column: return widget.get()
-        elif type(widget) is psg.Frame: return widget.get()
-        elif type(widget) is psg.Input: return widget.get()
-        elif type(widget) is psg.Listbox:
-            items = widget.get()
-            if len(items) > 0:
-                return items[0]
-            return ''
-        elif type(widget) is psg.Multiline: return widget.get()
-        elif type(widget) is psg.Text: return widget.get()
-        return None
-
-    # Update a property
-    def updateProperty(self, element, property, value):
-        if property == 'disabled':
-            element.update(disabled=value)
-        elif property == 'text':
-            element.update(text=value)
-        elif property == 'value':
-            element.update(value=value)
-        elif property == 'values':
-            element.update(values=value)
-
-    def getSize(self, args):
-        size = args['size']
-        if size == (None, None):
-            return size
-        size = size.split()
-        return (size[0], size[1])
-
-    def getDefaultButton(self, args):
-        args['button_text'] = ''
-        args['disabled'] = False
-        args['size'] = (None, None)
-
-    def createButton(self, layout, args):
-        return psg.Button(button_text=args['button_text'], disabled=args['disabled'], size=self.getSize(args))
-
-    def getDefaultCheckbox(self, args):
-        args['text'] = ''
-        args['key'] = None
-        args['size'] = (None, None)
-        args['expand_x'] = False
-
-    def createCheckbox(self, layout, args):
-        return psg.Checkbox(args['text'], key=args['key'], expand_x=args['expand_x'], size=self.getSize(args))
-
-    def getDefaultColumn(self, args):
-        args['expand_x'] = False
-        args['pad'] = (0, 0)
-
-    def createColumn(self, layout, args):
-        return psg.Column(layout, expand_x=args['expand_x'], pad=args['pad'])
-
-    def getDefaultFrame(self, args):
-        args['title'] = ''
-        args['border_width'] = 1
-        args['expand_x'] = False
-        args['pad'] = (0, 0)
-
-    def createFrame(self, layout, args):
-        return psg.Frame(args['title'], layout, border_width=args['border_width'], expand_x=args['expand_x'], pad=args['pad'])
-
-    def getDefaultInput(self, args):
-        args['default_text'] = ''
-        args['key'] = None
-        args['size'] = (None, None)
-
-    def createInput(self, layout, args):
-        return psg.Input(default_text=args['default_text'], key=args['key'], size=self.getSize(args))
-
-    def getDefaultListbox(self, args):
-        args['list'] = []
-        args['key'] = [None]
-        args['size'] = '10 2'
-        args['pad'] = 1
-        args['select_mode'] = None
-
-    def createListbox(self, layout, args):
-        return psg.Listbox([], key=args['key'], pad=args['pad'], size=self.getSize(args))
-
-    def getDefaultMultiline(self, args):
-        args['default_text'] = ''
-        args['key'] = None
-        args['size'] = (None, None)
-
-    def createMultiline(self, layout, args):
-        return psg.Multiline(default_text=args['default_text'], key=args['key'], size=self.getSize(args))
-
-    def getDefaultText(self, args):
-        args['text'] = ''
-        args['key'] = None
-        args['size'] = (None, None)
-        args['expand_x'] = False
-
-    def createText(self, layouts, args):
-        return psg.Text(text=args['text'], expand_x=args['expand_x'], key=args['key'], size=self.getSize(args))
-