Implement a drop-down box for CDI value maps.

Author: Poikilos

examples/tkexamples/cdiform.py

@@ -198,15 +198,24 @@ def onTreeSelect(self, event: tk.Event):
             cdivar = cm.toCDIVar()
             tkvar = None
             v_widget = None
-            if cdivar.max:
+            mapToValue = cm.valueMap()
+            self.mapToValue = mapToValue
+            if mapToValue:
+                tkvar = tk.StringVar(self.root)
+                v_widget = ttk.Combobox(self.cdiSettingFrame,
+                                        textvariable=tkvar,
+                                        values=list(mapToValue.keys()))
+                v_widget.mapToValue = mapToValue
+            elif 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)
+                v_widget = ttk.LabeledScale(self.cdiSettingFrame,
+                                            variable=tkvar)
                 # ^ widget.scale is ttk.Scale, widget.label is ttk.Label
                 # ^ a.k.a. Slider (if not using Tk)
                 v_widget.scale.cdivar = cdivar

openlcb/cdimemo.py

@@ -277,6 +277,67 @@ def toXMLEnd(self):
         memoRepr += ">"
         return memoRepr
 
+    def valueMap(self):
+        # type: () -> Union[dict, None]
+        """Map each relation in a dict.
+        Property and value are swapped to make the result a lookup
+        table where the key is the user-facing caption.
+        """
+        mapMemo = self.getChildByTag("map")
+        if mapMemo is None:
+            return None
+        results = OrderedDict()
+        for childRelation in mapMemo.children:
+            if childRelation.tag != "relation":
+                logger.warning(f"expected relation got {childRelation.tag}")
+                continue
+            keyMemo = childRelation.getChildByTag("property")
+            valueMemo = childRelation.getChildByTag("value")
+            if not keyMemo:
+                logger.warning("expected property in relation for"
+                               f" {self.getChildContent('name')}")
+                continue
+            if not valueMemo:
+                logger.warning("expected value in relation for"
+                               f" {self.getChildContent('name')}")
+                continue
+            prop = keyMemo.content.strip() if keyMemo.content else None
+            value = valueMemo.content.strip() if valueMemo.content else None
+            if not prop:
+                logger.warning("expected content for property in relation for"
+                               f" {self.getChildContent('name')}")
+                continue
+            if not value:
+                logger.warning("expected content for value in relation for"
+                               f" {self.getChildContent('name')}")
+                continue
+            if value in results:
+                logger.warning(f"expected only one value {repr(value)}"
+                               f" (property {repr(prop)}) in relation for"
+                               f" {self.getChildContent('name')}")
+            results[value] = prop  # reverse to make it a lookup by caption
+        return results
+
+    def keyMap(self):
+        # type: () -> Union[dict, None]
+        """Map each relation in a dict where property is key.
+        NOTE: As per CDI, value is the visible caption.
+        """
+        tmp = self.valueMap()
+        if not tmp:
+            return None
+        results = OrderedDict()
+        for k, v in tmp.items():
+            results[v] = k
+        return results
+
+    def getChildByTag(self, tag):
+        # type: (str) -> Union[CDIMemo, None]
+        for child in self.children:
+            if child.tag == tag:
+                return child
+        return None
+
     def toCDIVar(self):
         # type: () -> CDIVar
         """Create a CDIVar from descriptors (child elements of self).