Add preliminary CDI variable editor (only default, no read/write. Add CDIVar and OpenLCBAction).

Author: Poikilos

examples/examples_gui.py

@@ -459,8 +459,15 @@ def _gui(self, parent):
             state=tk.DISABLED,  # enabled on connect success callback
         )
         self.cdi_refresh_button.grid(row=self.cdi_row, column=1)
+        self.cdi_row += 1
 
+        self.cdiSettingFrame = ttk.Frame(self.cdi_tab)
+        self.cdiSettingFrame.grid(row=self.cdi_row+1, column=1)
+        # NOTE: ^ See self.cdi_form.setSettingsContainer in setupNetwork
+        # ^ +1 to row so it is across from _treeview
+        #   below invisible status label in second row on left
         self.cdi_row += 1
+
         self.network = None
         self.cdi_form = None  # type: CDIForm|None
         # ^ CDIForm or other XMLDataProcessor subclass
@@ -494,6 +501,7 @@ def _gui(self, parent):
     def setupNetwork(self):
         self.network = OpenLCBNetwork(self.getValue('localNodeID'))
         self.cdi_form = CDIForm(self.network.canLink, self.cdi_tab)
+        self.cdi_form.setSettingsContainer(self.cdiSettingFrame)
         self.cdi_form.setStatusCallback(self.setStatus)
         # ^ formerly OpenLCBNetwork() subclass
         # ^ CDIForm has ttk.Treeview etc.

examples/tkexamples/cdiform.py

@@ -15,13 +15,15 @@
 import tkinter as tk
 import warnings
 
-from tkinter import ttk
+from tkinter import EventType, ttk
 
 from collections import deque
 from logging import getLogger
 from typing import Any, Callable, Dict, Union
 from xml.etree import ElementTree as ET
 
+from openlcb.cdivar import CLASSNAME_TYPES, CDIVar
+
 
 if __name__ == "__main__":
     logger = getLogger(__file__)
@@ -75,10 +77,19 @@ def __init__(self, *args, **kwargs):
         if hasattr(self.parent, 'root'):
             self.root = self.parent.root
         self._container = self  # where to put visible widgets
-        self._treeview = None  # type: ttk.Treeview
+        self._treeview = None  # type: ttk.Treeview|None
+        self._treeMemos = {}  # type: Dict[str, CDIMemo]
+
         self._gui(self._container)
         self.cursorCol = 0
 
+        self.cdiSettingWidgets = []  # type: list[tk.Widget]
+        self.cdiSettingRow = 0
+        self.cdiSettingFrame = None  # type: Union[ttk.Frame, tk.Frame, None]
+
+    def setSettingsContainer(self, container: Union[ttk.Frame, tk.Frame]):
+        self.cdiSettingFrame = container
+
     def _gui(self, container: tk.Widget):
         if self._top_widgets:
             raise RuntimeError("gui can only be called once unless reset")
@@ -92,10 +103,94 @@ def _gui(self, container: tk.Widget):
         self._top_widgets.append(self._overview)
         self._treeview = ttk.Treeview(container)
         self._treeview.grid(sticky=tk.NSEW, row=len(self._top_widgets))
+        self._treeview.bind("<<TreeviewSelect>>", self.onTreeSelect)
         self.rowconfigure(len(self._top_widgets), weight=1)  # weight=1: expand
         self._top_widgets.append(self._treeview)
         self._current_iid = 0   # id of Treeview element
 
+    def onTreeSelect(self, event: tk.Event):
+        # print(f"event={event}")
+        # print(f"dir(event)={dir(event)}")
+        # print(f"event.__dict__={event.__dict__}")
+        # ^ {'serial': 794, 'num': '??', 'height': '??', 'keycode':
+        #   '??', 'state': 0, 'time': 0, 'width': '??', 'x': 0, 'y': 0,
+        #   'char': '??', 'send_event': False, 'keysym': '??',
+        #   'keysym_num': '??', 'type': <EventType.VirtualEvent: '35'>,
+        #   'widget': <tkinter.ttk.Treeview object
+        #   .!mainform.!notebook.!frame.!cdiform.!treeview>, 'x_root':
+        #   0, 'y_root': 0, 'delta': 0}
+        for iid in event.widget.selection():
+            item = event.widget.item(iid)  # type: dict
+            # ^ such as {'text': 'Track Output', 'image': '',
+            #   'values': [CDIMemo], 'open': 0, 'tags': ''}
+            cm = self._treeMemos[iid]
+            # print(f"type(item)={type(item)}")
+            # raise NotImplementedError(item)
+            # print(f"cm={cm}")
+            self.clearSettingWidgets()
+            if cm.tag not in CLASSNAME_TYPES:
+                # Non-value (such as segment or group)
+                #   So there is nothing to do.
+                return
+
+            name = cm.getChildContent("name")
+            if name is None:
+                # self.setStatus("Selected element has no name.")
+                break
+
+            nameLabel = ttk.Label(self.cdiSettingFrame, text=name)
+            nameLabel.tip = cm.getChildContent("description")
+            nameLabel.grid(column=0, row=self.cdiSettingRow)
+            self.cdiSettingWidgets.append(nameLabel)
+            # self.cdiSettingRow += 1
+            cdivar = cm.toCDIVar()
+            tkvar = None
+            v_widget = None
+            if cdivar.max:
+                if cdivar.className == "int":
+                    tkvar = tk.IntVar(self.root)
+                elif cdivar.className == "float":
+                    tkvar = tk.DoubleVar(self.root)
+                else:
+                    raise TypeError("Device should not specify max for {}"
+                                    .format(cdivar.className))
+
+                v_widget = ttk.LabeledScale(self.cdiSettingFrame, variable=tkvar)
+                # ^ widget.scale is ttk.Scale, widget.label is ttk.Label
+                v_widget.scale.cdivar = cdivar
+                v_widget.scale.tip = nameLabel.tip
+            else:
+                tkvar = tk.StringVar(self.root)
+                v_widget = ttk.Entry(self.cdiSettingFrame, textvariable=tkvar)
+            v_widget.grid(column=1, row=self.cdiSettingRow)
+            self.cdiSettingRow += 1
+            self.cdiSettingWidgets.append(v_widget)
+            if cdivar.default is not None:
+                tkvar.set(cdivar.default)
+            v_widget.cdivar = cdivar
+            v_widget.tip = nameLabel.tip
+
+
+            address_str = ""
+            if address_str is not None:
+                address_str = str(cm.address)
+            a_widget = ttk.Label(self.cdiSettingFrame, text="(Address:")
+            a_widget.grid(column=0, row=self.cdiSettingRow, sticky=tk.W)
+            av_widget = ttk.Label(self.cdiSettingFrame, text=address_str + ")")
+            av_widget.grid(column=1, row=self.cdiSettingRow)
+            self.cdiSettingWidgets.append(a_widget)
+            self.cdiSettingWidgets.append(av_widget)
+            self.cdiSettingRow += 1
+
+            break
+
+    def clearSettingWidgets(self):
+        for widget in self.cdiSettingWidgets:
+            widget.grid_forget()
+            widget.destroy()
+        del self.cdiSettingWidgets[:]
+        self.cdiSettingRow = 0
+
     def clear(self):
         while self._top_widgets:
             widget = self._top_widgets.pop()
@@ -337,6 +432,7 @@ def _onPushScope(self, cm: CDIMemo):
                 iid=self._current_iid,
                 text=content,
             )
+            self._treeMemos[new_branch] = cm
             # values=(), image=None
             # self._tag_stack[-1].iid = new_branch
             # NOTE: ^ _tag_stack is unreliable due to race condition!
@@ -358,6 +454,7 @@ def _onPushScope(self, cm: CDIMemo):
                 iid=self._current_iid,
                 text=content,
             )
+            self._treeMemos[new_branch] = cm
             # values=(), image=None
             # self._tag_stack[-1].iid = new_branch
             # NOTE: ^ _tag_stack is unreliable due to race condition!

openlcb/cdimemo.py

@@ -1,10 +1,22 @@
+from collections import OrderedDict
+import json
+import math
 import xml.etree.ElementTree
+# import xml.etree.ElementTree as ET
 
 from typing import List, Optional, Union
 
+from openlcb.cdivar import FLOAT_MAXIMUMS, NUM_TYPES, CDIVar
 from openlcb.message import Message
 
 
+def element_ordered(el: xml.etree.ElementTree.Element):
+    od = OrderedDict()
+    od['tag'] = el.tag
+    od['attrib'] = el.attrib
+    return od
+
+
 class CDIMemo:
     """Store parsing state info as a tree (This is a tree node)
 
@@ -48,13 +60,41 @@ def __init__(self, tag: Union[str, None] = None,
         self.message: Union[Message, None] = None  # type: Message|None
         self.iid = None  # type: str|None
         self.address = None  # type: int|None
+        self.cdivar = None  # type: CDIVar|None
         self.children = []  # type: List[CDIMemo]
 
     def getTag(self):
         if self.element is None:
             return self.tag  # May have been set manually (stray end tag)
         return self.element.tag
 
+    def getChildContentN(self, tag, className) -> Union[int, float, None]:
+        for child in self.children:
+            if child.tag == tag:
+                if child.content is None:
+                    return None
+                if className == "int":
+                    if not child.content.strip():
+                        return None
+                    return int(child.content.strip())
+                elif className == "float":
+                    if not child.content.strip():
+                        return None
+                    return float(child.content.strip())
+                else:
+                    raise NotImplementedError(
+                        "className {} is not implemented in getChildContent"
+                        .format(className))
+        return None
+
+    def getChildContent(self, tag) -> Union[str, None]:
+        for child in self.children:
+            if child.tag == tag:
+                if child.content is None:
+                    return None
+                return child.content.strip()
+        return None
+
     def copy(self):
         cm = CDIMemo()
         for k, v in self.__dict__.items():
@@ -91,5 +131,72 @@ def get(self, key):
     def __repr__(self):
         return repr(self.__dict__)
 
+    @staticmethod
+    def to_dict(cm):
+        d = OrderedDict()
+        for k, v in cm.__dict__.items():
+            # if k == 'children':
+            #     continue
+            if k == 'parent':
+                continue
+            if isinstance(v, xml.etree.ElementTree.Element):
+                d[k] = element_ordered(v)
+                continue
+            d[k] = v
+        return d
+
     def __str__(self):
-        return str(self.__dict__)
+        return json.dumps(CDIMemo.to_dict(self), default=CDIMemo.to_dict)
+
+    def toCDIVar(self):
+        """Create a CDIVar from descriptors (child elements of self).
+        See LCC "Configuration Description Information" Standard.
+        """
+        result = CDIVar(self.tag)
+        assert (self.tag is not None) and (self.tag.strip())
+        result.className = self.tag.lower()
+        if self.element:
+            result.floatFormat = self.element.attrib.get('floatFormat')
+        this_t = NUM_TYPES.get(self.tag) if self.tag else None
+        if this_t is not None:
+            result.min = self.getChildContentN("min", result.className)
+            result.max = self.getChildContentN("max", result.className)
+            result.default = self.getChildContentN("default", result.className)
+        result.size = self.getSize()
+
+        if result.className == "int":
+            if result.min is None:
+                result.min = 0
+            elif result.min < 0:
+                result.signed = True
+            # if self.size is not None:
+            if result.size not in [1, 2, 4, 8]:
+                raise AttributeError(
+                    f"expected 1,2,4,8 for int size, got {result.size}"
+                    f" in children={json.dumps(self.children, sort_keys=True, indent=2,
+                                      default=CDIMemo.to_dict)}")
+            if result.max is None:
+                if result.signed:
+                    result.max = math.pow(2, result.size * 8 - 1) - 1
+                else:
+                    result.max = math.pow(2, result.size * 8)
+        elif result.className == "float":
+            result.signed = True  # float is always signed in CDI
+            if result.min is None:
+                result.min = 0.0
+            # if self.size is not None:
+            if result.size not in [2, 4, 8]:
+                raise AttributeError(
+                    f"expected 2,4,8 for float size, got {result.size}")
+            if result.max is None:
+                assert isinstance(result.size, int)
+                result.max = FLOAT_MAXIMUMS[result.size * 8]
+        return result
+
+    def getSize(self):
+        if self.element is None:
+            return None
+        size = self.element.attrib.get('size')
+        if size is None:
+            return None
+        return int(size)

openlcb/cdivar.py

@@ -0,0 +1,46 @@
+
+import json
+import math
+
+from openlcb import emit_cast
+from typing import Any, Type
+
+from openlcb.eventid import EventID
+from openlcb.openlcbaction import OpenLCBAction
+
+
+NUM_TYPES = {'int': int, 'float': float}  # type: dict[str, Type]
+# Assumes "IEEE" in LCC CDI Standard means IEEE 754-2008:
+FLOAT_MAXIMUMS = {16: 65504.0, 32: 3.40e38, 64: 1.80e308}  # type: dict[int, float]  # noqa: E501
+CLASSNAME_TYPES = {'int': int, 'float': float, 'string': str,
+                   'blob': bytearray, 'eventid': EventID,
+                   'action': OpenLCBAction}
+
+
+class CDIVar:
+    """
+    Attributes:
+        floatFormat (str): Optional printf-style format
+            (for className == "float").
+        signed (bool): Whether the value is signed (False unless min is
+            negative). Defaults to True.
+            See LCC "Configuration Description Information" Standard.
+        value (Any): The value read from the device (type should be
+            from CLASSNAME_TYPES values).
+    """
+    TYPED_KEYS = ['min', 'max', 'default']
+
+    def __init__(self, className):
+        assert isinstance(className, str), \
+            f"Expected {CLASSNAME_TYPES.keys()} got {emit_cast(className)}"
+        assert className, f"Expected {CLASSNAME_TYPES.keys()} got {className}"
+        assert className in CLASSNAME_TYPES, \
+            f"Expected {CLASSNAME_TYPES.keys()} got {className}"
+        self.className = className  # type: str
+        self.signed = False  # type: bool
+        self.value = None  # type: Any
+        self.min = None  # type: int|float|None
+        self.max = None  # type: int|float|None
+        self.default = None  # type: int|float|None
+        self.size = None  # type: int|None
+        self.floatFormat = None  # type: str|None

openlcb/openlcbaction.py

@@ -0,0 +1,6 @@
+class OpenLCBAction:
+    """LCC Action
+    See LCC "Configuration Description Information" Standard.
+    """
+    pass
+    # TODO: Finish this.

python-openlcb.code-workspace

@@ -40,6 +40,7 @@
 			"canphysicallayersimulation",
 			"cdiform",
 			"cdimemo",
+			"cdivar",
 			"columnspan",
 			"controlframe",
 			"datagram",
@@ -65,7 +66,6 @@
 			"MDNS",
 			"mdnsconventions",
 			"memoryservice",
-			"xmldataprocessor",
 			"metas",
 			"MSGLEN",
 			"nodeid",
@@ -104,6 +104,7 @@
 			"usbmodem",
 			"WASI",
 			"winnative",
+			"xmldataprocessor",
 			"xscrollcommand",
 			"zeroconf"
 		]