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

    10

    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_SINT":{},

    21

    "HMI_INT":{},

    22

    "HMI_DINT":{},

    23

    "HMI_LINT":{},

    24

    "HMI_DINT":{},

    25

    "HMI_USINT":{},

    26

    "HMI_UINT":{},

    27

    "HMI_UDINT":{},

    28

    "HMI_ULINT":{},

    29

    "HMI_BOOL":{},

    30

    "HMI_REAL":{}

    31

}

    32

    33

HMI_TYPES = list(HMI_TYPES_DESC.keys())

    34

    35

class HMITreeNode(object):

    36

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

    37

        self.path = path

    38

        self.name = name

    39

        self.nodetype = nodetype

    40

        self.hmiclass = hmiclass

    41

        self.parent = None

    42

    43

        if iectype is not None:

    44

            self.iectype = iectype

    45

            self.vartype = vartype

    46

            self.cpath = cpath

    47

    48

        if nodetype in ["HMI_NODE"]:

    49

            self.children = []

    50

    51

    def pprint(self, indent = 0):

    52

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

    53

        if hasattr(self, "children"):

    54

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

    55

                              for child in self.children])

    56

            res += "\n"

    57

    58

        return res

    59

    60

    def place_node(self, node):

    61

        best_child = None

    62

        known_best_match = 0

    63

        potential_siblings = {}

    64

        for child in self.children:

    65

            if child.path is not None:

    66

                in_common = 0

    67

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

    68

                    if child_path_item == node_path_item:

    69

                        in_common +=1

    70

                    else:

    71

                        break

    72

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

    73

                # must match candidate node (except for name part)

    74

                # since candidate would become child of that node

    75

                if in_common > known_best_match and \

    76

                   child.nodetype == "HMI_NODE" and \

    77

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

    78

                    known_best_match = in_common

    79

                    best_child = child

    80

                else:

    81

                    potential_siblings[child.path[

    82

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

    83

        if best_child is not None:

    84

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

    85

                return "Duplicate_HMI_NODE", best_child

    86

            return best_child.place_node(node)

    87

        else:

    88

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

    89

            if candidate_name in potential_siblings:

    90

                return "Non_Unique", potential_siblings[candidate_name]

    91

    92

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

    93

                prev = self.children[-1]

    94

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

    95

                    return "Late_HMI_NODE",prev

    96

    97

            node.parent = weakref.ref(self)

    98

            self.children.append(node)

    99

            return None

   100

   101

    def etree(self, add_hash=False):

   102

   103

        attribs = dict(name=self.name)

   104

        if self.path is not None:

   105

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

   106

   107

        if self.hmiclass is not None:

   108

            attribs["class"] = self.hmiclass

   109

   110

        if add_hash:

   111

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

   112

   113

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

   114

   115

        if hasattr(self, "children"):

   116

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

   117

                res.append(child_etree)

   118

   119

        return res

   120

   121

    @classmethod

   122

    def from_etree(cls, enode):

   123

        """

   124

        alternative constructor, restoring HMI Tree from XML backup

   125

        note: all C-related information is gone, 

   126

              this restore is only for tree display and widget picking

   127

        """

   128

        nodetype = enode.tag

   129

        attributes = enode.attrib

   130

        name = attributes["name"]

   131

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

   132

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

   133

        # hash is computed on demand

   134

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

   135

        for child in enode.iterchildren():

   136

            newnode = cls.from_etree(child)

   137

            newnode.parent = weakref.ref(node)

   138

            node.children.append(newnode)

   139

        return node

   140

   141

    def traverse(self):

   142

        yield self

   143

        if hasattr(self, "children"):

   144

            for c in self.children:

   145

                for yoodl in c.traverse():

   146

                    yield yoodl

   147

   148

    def hmi_path(self):

   149

        if self.parent is None:

   150

            return "/"

   151

        p = self.parent()

   152

        if p.parent is None:

   153

            return "/" + self.name

   154

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

   155

   156

    def hash(self):

   157

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

   158

        s = hashlib.new('md5')

   159

        self._hash(s)

   160

        # limit size to HMI_HASH_SIZE as in svghmi.c

   161

        return s.digest()[:8]

   162

   163

    def _hash(self, s):

   164

        s.update(self.name.encode() + self.nodetype.encode())

   165

        if hasattr(self, "children"):

   166

            for c in self.children:

   167

                c._hash(s)

   168

   169

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

   170

                 ("heartbeat", "HMI_INT")]

   171