1 #!/usr/bin/env python

     2 # -*- coding: utf-8 -*-

     3 

     4 # This file is part of Beremiz

     5 # Copyright (C) 2021: Edouard TISSERANT

     6 #

     7 # See COPYING file for copyrights details.

     8 

     9 from __future__ import absolute_import

    10 from itertools import izip, imap

    11 from pprint import pformat

    12 import weakref

    13 import hashlib

    14 

    15 from lxml import etree

    16 

    17 HMI_TYPES_DESC = {

    18     "HMI_NODE":{},

    19     "HMI_STRING":{},

    20     "HMI_INT":{},

    21     "HMI_BOOL":{},

    22     "HMI_REAL":{}

    23 }

    24 

    25 HMI_TYPES = HMI_TYPES_DESC.keys()

    26 

    27 class HMITreeNode(object):

    28     def __init__(self, path, name, nodetype, iectype = None, vartype = None, cpath = None, hmiclass = None):

    29         self.path = path

    30         self.name = name

    31         self.nodetype = nodetype

    32         self.hmiclass = hmiclass

    33         self.parent = None

    34 

    35         if iectype is not None:

    36             self.iectype = iectype

    37             self.vartype = vartype

    38             self.cpath = cpath

    39 

    40         if nodetype in ["HMI_NODE"]:

    41             self.children = []

    42 

    43     def pprint(self, indent = 0):

    44         res = ">"*indent + pformat(self.__dict__, indent = indent, depth = 1) + "\n"

    45         if hasattr(self, "children"):

    46             res += "\n".join([child.pprint(indent = indent + 1)

    47                               for child in self.children])

    48             res += "\n"

    49 

    50         return res

    51 

    52     def place_node(self, node):

    53         best_child = None

    54         known_best_match = 0

    55         potential_siblings = {}

    56         for child in self.children:

    57             if child.path is not None:

    58                 in_common = 0

    59                 for child_path_item, node_path_item in izip(child.path, node.path):

    60                     if child_path_item == node_path_item:

    61                         in_common +=1

    62                     else:

    63                         break

    64                 # Match can only be HMI_NODE, and the whole path of node

    65                 # must match candidate node (except for name part)

    66                 # since candidate would become child of that node

    67                 if in_common > known_best_match and \

    68                    child.nodetype == "HMI_NODE" and \

    69                    in_common == len(child.path) - 1:

    70                     known_best_match = in_common

    71                     best_child = child

    72                 else:

    73                     potential_siblings[child.path[

    74                         -2 if child.nodetype == "HMI_NODE" else -1]] = child

    75         if best_child is not None:

    76             if node.nodetype == "HMI_NODE" and best_child.path[:-1] == node.path[:-1]:

    77                 return "Duplicate_HMI_NODE", best_child

    78             return best_child.place_node(node)

    79         else:

    80             candidate_name = node.path[-2 if node.nodetype == "HMI_NODE" else -1]

    81             if candidate_name in potential_siblings:

    82                 return "Non_Unique", potential_siblings[candidate_name]

    83 

    84             if node.nodetype == "HMI_NODE" and len(self.children) > 0:

    85                 prev = self.children[-1]

    86                 if prev.path[:-1] == node.path[:-1]:

    87                     return "Late_HMI_NODE",prev

    88 

    89             node.parent = weakref.ref(self)

    90             self.children.append(node)

    91             return None

    92 

    93     def etree(self, add_hash=False):

    94 

    95         attribs = dict(name=self.name)

    96         if self.path is not None:

    97             attribs["path"] = ".".join(self.path)

    98 

    99         if self.hmiclass is not None:

   100             attribs["class"] = self.hmiclass

   101 

   102         if add_hash:

   103             attribs["hash"] = ",".join(map(str,self.hash()))

   104 

   105         res = etree.Element(self.nodetype, **attribs)

   106 

   107         if hasattr(self, "children"):

   108             for child_etree in imap(lambda c:c.etree(), self.children):

   109                 res.append(child_etree)

   110 

   111         return res

   112 

   113     @classmethod

   114     def from_etree(cls, enode):

   115         """

   116         alternative constructor, restoring HMI Tree from XML backup

   117         note: all C-related information is gone, 

   118               this restore is only for tree display and widget picking

   119         """

   120         nodetype = enode.tag

   121         attributes = enode.attrib

   122         name = attributes["name"]

   123         path = attributes["path"].split('.') if "path" in attributes else None 

   124         hmiclass = attributes.get("class", None)

   125         # hash is computed on demand

   126         node = cls(path, name, nodetype, hmiclass=hmiclass)

   127         for child in enode.iterchildren():

   128             newnode = cls.from_etree(child)

   129             newnode.parent = weakref.ref(node)

   130             node.children.append(newnode)

   131         return node

   132 

   133     def traverse(self):

   134         yield self

   135         if hasattr(self, "children"):

   136             for c in self.children:

   137                 for yoodl in c.traverse():

   138                     yield yoodl

   139 

   140     def hmi_path(self):

   141         if self.parent is None:

   142             return "/"

   143         p = self.parent()

   144         if p.parent is None:

   145             return "/" + self.name

   146         return p.hmi_path() + "/" + self.name

   147 

   148     def hash(self):

   149         """ Produce a hash, any change in HMI tree structure change that hash """

   150         s = hashlib.new('md5')

   151         self._hash(s)

   152         # limit size to HMI_HASH_SIZE as in svghmi.c

   153         return map(ord,s.digest())[:8]

   154 

   155     def _hash(self, s):

   156         s.update(str((self.name,self.nodetype)))

   157         if hasattr(self, "children"):

   158             for c in self.children:

   159                 c._hash(s)

   160 

   161 SPECIAL_NODES = [("HMI_ROOT", "HMI_NODE"),

   162                  ("heartbeat", "HMI_INT")]

   163                  # ("current_page", "HMI_STRING")])

   164