1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz

     5

# Copyright (C) 2019: Edouard TISSERANT

     6

#

     7

# See COPYING file for copyrights details.

     8

     9

from __future__ import absolute_import

    10

import os

    11

import shutil

    12

from itertools import izip, imap

    13

from pprint import pformat

    14

import hashlib

    15

import weakref

    16

import shlex

    17

    18

import wx

    19

import wx.dataview as dv

    20

    21

from lxml import etree

    22

from lxml.etree import XSLTApplyError

    23

    24

import util.paths as paths

    25

from POULibrary import POULibrary

    26

from docutil import open_svg, get_inkscape_path

    27

    28

from util.ProcessLogger import ProcessLogger

    29

from runtime.typemapping import DebugTypesSize

    30

import targets

    31

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    32

from XSLTransform import XSLTransform

    33

    34

HMI_TYPES_DESC = {

    35

    "HMI_NODE":{},

    36

    "HMI_STRING":{},

    37

    "HMI_INT":{},

    38

    "HMI_BOOL":{}

    39

}

    40

    41

HMI_TYPES = HMI_TYPES_DESC.keys()

    42

    43

    44

ScriptDirectory = paths.AbsDir(__file__)

    45

    46

class HMITreeNode(object):

    47

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

    48

        self.path = path

    49

        self.name = name

    50

        self.nodetype = nodetype

    51

        self.hmiclass = hmiclass

    52

    53

        if iectype is not None:

    54

            self.iectype = iectype

    55

            self.vartype = vartype

    56

            self.cpath = cpath

    57

    58

        if nodetype in ["HMI_NODE", "HMI_ROOT"]:

    59

            self.children = []

    60

    61

    def pprint(self, indent = 0):

    62

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

    63

        if hasattr(self, "children"):

    64

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

    65

                              for child in self.children])

    66

            res += "\n"

    67

    68

        return res

    69

    70

    def place_node(self, node):

    71

        best_child = None

    72

        known_best_match = 0

    73

        for child in self.children:

    74

            if child.path is not None:

    75

                in_common = 0

    76

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

    77

                    if child_path_item == node_path_item:

    78

                        in_common +=1

    79

                    else:

    80

                        break

    81

                if in_common > known_best_match:

    82

                    known_best_match = in_common

    83

                    best_child = child

    84

        if best_child is not None and best_child.nodetype == "HMI_NODE":

    85

            best_child.place_node(node)

    86

        else:

    87

            self.children.append(node)

    88

    89

    def etree(self, add_hash=False):

    90

    91

        attribs = dict(name=self.name)

    92

        if self.path is not None:

    93

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

    94

    95

        if self.hmiclass is not None:

    96

            attribs["class"] = self.hmiclass

    97

    98

        if add_hash:

    99

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

   100

   101

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

   102

   103

        if hasattr(self, "children"):

   104

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

   105

                res.append(child_etree)

   106

   107

        return res

   108

   109

    def traverse(self):

   110

        yield self

   111

        if hasattr(self, "children"):

   112

            for c in self.children:

   113

                for yoodl in c.traverse():

   114

                    yield yoodl

   115

   116

   117

    def hash(self):

   118

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

   119

        s = hashlib.new('md5')

   120

        self._hash(s)

   121

        # limit size to HMI_HASH_SIZE as in svghmi.c

   122

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

   123

   124

    def _hash(self, s):

   125

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

   126

        if hasattr(self, "children"):

   127

            for c in self.children:

   128

                c._hash(s)

   129

   130

# module scope for HMITree root

   131

# so that CTN can use HMITree deduced in Library

   132

# note: this only works because library's Generate_C is

   133

#       systematicaly invoked before CTN's CTNGenerate_C

   134

   135

hmi_tree_root = None

   136

   137

on_hmitree_update = None

   138

   139

SPECIAL_NODES = [("heartbeat", "HMI_INT")]

   140

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

   141

   142

class SVGHMILibrary(POULibrary):

   143

    def GetLibraryPath(self):

   144

         return paths.AbsNeighbourFile(__file__, "pous.xml")

   145

   146

    def Generate_C(self, buildpath, varlist, IECCFLAGS):

   147

        global hmi_tree_root, on_hmitree_update

   148

   149

        """

   150

        PLC Instance Tree:

   151

          prog0

   152

           +->v1 HMI_INT

   153

           +->v2 HMI_INT

   154

           +->fb0 (type mhoo)

   155

           |   +->va HMI_NODE

   156

           |   +->v3 HMI_INT

   157

           |   +->v4 HMI_INT

   158

           |

   159

           +->fb1 (type mhoo)

   160

           |   +->va HMI_NODE

   161

           |   +->v3 HMI_INT

   162

           |   +->v4 HMI_INT

   163

           |

   164

           +->fb2

   165

               +->v5 HMI_IN

   166

   167

        HMI tree:

   168

          hmi0

   169

           +->v1

   170

           +->v2

   171

           +->fb0 class:va

   172

           |   +-> v3

   173

           |   +-> v4

   174

           |

   175

           +->fb1 class:va

   176

           |   +-> v3

   177

           |   +-> v4

   178

           |

   179

           +->v5

   180

   181

        """

   182

   183

        # Filter known HMI types

   184

        hmi_types_instances = [v for v in varlist if v["derived"] in HMI_TYPES]

   185

   186

        hmi_tree_root = HMITreeNode(None, "/", "HMI_ROOT")

   187

   188

        # deduce HMI tree from PLC HMI_* instances

   189

        for v in hmi_types_instances:

   190

            path = v["IEC_path"].split(".")

   191

            # ignores variables starting with _TMP_

   192

            if path[-1].startswith("_TMP_"):

   193

                continue

   194

            derived = v["derived"]

   195

            kwargs={}

   196

            if derived == "HMI_NODE":

   197

                # TODO : make problem if HMI_NODE used in CONFIG or RESOURCE

   198

                name = path[-2]

   199

                kwargs['hmiclass'] = path[-1]

   200

            else:

   201

                name = path[-1]

   202

            new_node = HMITreeNode(path, name, derived, v["type"], v["vartype"], v["C_path"], **kwargs)

   203

            hmi_tree_root.place_node(new_node)

   204

   205

        if on_hmitree_update is not None:

   206

            on_hmitree_update()

   207

   208

        variable_decl_array = []

   209

        extern_variables_declarations = []

   210

        buf_index = 0

   211

        item_count = 0

   212

        found_heartbeat = False

   213

   214

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   215

   216

        for node in hmi_tree_root.traverse():

   217

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   218

                hmi_tree_hearbeat_index = item_count

   219

                found_heartbeat = True

   220

                extern_variables_declarations += [

   221

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   222

                ]

   223

            if hasattr(node, "iectype") and node.nodetype != "HMI_NODE":

   224

                sz = DebugTypesSize.get(node.iectype, 0)

   225

                variable_decl_array += [

   226

                    "{&(" + node.cpath + "), " + node.iectype + {

   227

                        "EXT": "_P_ENUM",

   228

                        "IN":  "_P_ENUM",

   229

                        "MEM": "_O_ENUM",

   230

                        "OUT": "_O_ENUM",

   231

                        "VAR": "_ENUM"

   232

                    }[node.vartype] + ", " +

   233

                    str(buf_index) + ", 0, }"]

   234

                buf_index += sz

   235

                item_count += 1

   236

                if len(node.path) == 1:

   237

                    extern_variables_declarations += [

   238

                        "extern __IEC_" + node.iectype + "_" +

   239

                        "t" if node.vartype is "VAR" else "p"

   240

                        + node.cpath + ";"]

   241

   242

        assert(found_heartbeat)

   243

   244

        # TODO : filter only requiered external declarations

   245

        for v in varlist:

   246

            if v["C_path"].find('.') < 0:

   247

                extern_variables_declarations += [

   248

                    "extern %(type)s %(C_path)s;" % v]

   249

   250

        # TODO check if programs need to be declared separately

   251

        # "programs_declarations": "\n".join(["extern %(type)s %(C_path)s;" %

   252

        #                                     p for p in self._ProgramList]),

   253

   254

        # C code to observe/access HMI tree variables

   255

        svghmi_c_filepath = paths.AbsNeighbourFile(__file__, "svghmi.c")

   256

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   257

        svghmi_c_code = svghmi_c_file.read()

   258

        svghmi_c_file.close()

   259

        svghmi_c_code = svghmi_c_code % {

   260

            "variable_decl_array": ",\n".join(variable_decl_array),

   261

            "extern_variables_declarations": "\n".join(extern_variables_declarations),

   262

            "buffer_size": buf_index,

   263

            "item_count": item_count,

   264

            "var_access_code": targets.GetCode("var_access.c"),

   265

            "PLC_ticktime": self.GetCTR().GetTicktime(),

   266

            "hmi_hash_ints": ",".join(map(str,hmi_tree_root.hash()))

   267

            }

   268

   269

        gen_svghmi_c_path = os.path.join(buildpath, "svghmi.c")

   270

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   271

        gen_svghmi_c.write(svghmi_c_code)

   272

        gen_svghmi_c.close()

   273

   274

        # Python based WebSocket HMITree Server

   275

        svghmiserverfile = open(paths.AbsNeighbourFile(__file__, "svghmi_server.py"), 'r')

   276

        svghmiservercode = svghmiserverfile.read()

   277

        svghmiserverfile.close()

   278

   279

        runtimefile_path = os.path.join(buildpath, "runtime_svghmi.py")

   280

        runtimefile = open(runtimefile_path, 'w')

   281

        runtimefile.write(svghmiservercode)

   282

        runtimefile.close()

   283

   284

        return ((["svghmi"], [(gen_svghmi_c_path, IECCFLAGS)], True), "",

   285

                ("runtime_svghmi0.py", open(runtimefile_path, "rb")))

   286

   287

   288

class HMITreeSelector(wx.TreeCtrl):

   289

    def __init__(self, parent):

   290

        global on_hmitree_update

   291

        wx.TreeCtrl.__init__(self,parent,style=wx.TR_MULTIPLE)# | wx.TR_HIDE_ROOT)

   292

   293

        isz = (16,16)

   294

        self.il = il = wx.ImageList(*isz)

   295

        self.fldridx     = il.AddIcon(wx.ArtProvider.GetIcon(wx.ART_FOLDER,      wx.ART_OTHER, isz))

   296

        self.fldropenidx = il.AddIcon(wx.ArtProvider.GetIcon(wx.ART_FOLDER_OPEN, wx.ART_OTHER, isz))

   297

        self.fileidx     = il.AddIcon(wx.ArtProvider.GetIcon(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))

   298

        self.SetImageList(il)

   299

   300

        on_hmitree_update = self.SVGHMIEditorUpdater()

   301

        self.MakeTree()

   302

   303

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   304

        for c in current_hmitree_root.children:

   305

            if hasattr(c, "children"):

   306

                display_name = ('{} (class={})'.format(c.name, c.hmiclass)) \

   307

                               if c.hmiclass is not None else c.name

   308

                tc_child = self.AppendItem(current_tc_root, display_name)

   309

                self.SetPyData(tc_child, None)

   310

                self.SetItemImage(tc_child, self.fldridx, wx.TreeItemIcon_Normal)

   311

                self.SetItemImage(tc_child, self.fldropenidx, wx.TreeItemIcon_Expanded)

   312

   313

                self._recurseTree(c,tc_child)

   314

            else:

   315

                display_name = '{} {}'.format(c.nodetype[4:], c.name)

   316

                tc_child = self.AppendItem(current_tc_root, display_name)

   317

                self.SetPyData(tc_child, None)

   318

                self.SetItemImage(tc_child, self.fileidx, wx.TreeItemIcon_Normal)

   319

                self.SetItemImage(tc_child, self.fileidx, wx.TreeItemIcon_Expanded)

   320

   321

    def MakeTree(self):

   322

        global hmi_tree_root

   323

   324

        self.Freeze()

   325

   326

        self.root = None

   327

        self.DeleteAllItems()

   328

   329

        root_display_name = _("Please build to see HMI Tree") if hmi_tree_root is None else "HMI"

   330

        self.root = self.AddRoot(root_display_name)

   331

        self.SetPyData(self.root, None)

   332

        self.SetItemImage(self.root, self.fldridx, wx.TreeItemIcon_Normal)

   333

        self.SetItemImage(self.root, self.fldropenidx, wx.TreeItemIcon_Expanded)

   334

   335

        if hmi_tree_root is not None:

   336

            self._recurseTree(hmi_tree_root, self.root)

   337

   338

        self.Thaw()

   339

   340

    def SVGHMIEditorUpdater(self):

   341

        selfref = weakref.ref(self)

   342

        def SVGHMIEditorUpdate():

   343

            o = selfref()

   344

            if o is not None:

   345

                wx.CallAfter(o.MakeTree)

   346

        return SVGHMIEditorUpdate

   347

   348

class HMITreeView(wx.SplitterWindow):

   349

   350

    def __init__(self, parent):

   351

        wx.SplitterWindow.__init__(self, parent,

   352

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   353

   354

        self.SelectionTree = HMITreeSelector(self)

   355

        #self.Staging = wx.Panel(self)

   356

        #self.SplitHorizontally(self.SelectionTree, self.Staging, 200)

   357

        self.Initialize(self.SelectionTree)

   358

   359

   360

class SVGHMIEditor(ConfTreeNodeEditor):

   361

    CONFNODEEDITOR_TABS = [

   362

        (_("HMI Tree"), "CreateHMITreeView")]

   363

   364

    def CreateHMITreeView(self, parent):

   365

        #self.HMITreeView = HMITreeView(self)

   366

        return HMITreeSelector(parent)

   367

   368

   369

class SVGHMI(object):

   370

    XSD = """<?xml version="1.0" encoding="utf-8" ?>

   371

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   372

      <xsd:element name="SVGHMI">

   373

        <xsd:complexType>

   374

          <xsd:attribute name="OnStart" type="xsd:string" use="optional"/>

   375

          <xsd:attribute name="OnStop" type="xsd:string" use="optional"/>

   376

          <xsd:attribute name="OnWatchdog" type="xsd:string" use="optional"/>

   377

        </xsd:complexType>

   378

      </xsd:element>

   379

    </xsd:schema>

   380

    """

   381

   382

    EditorType = SVGHMIEditor

   383

   384

    ConfNodeMethods = [

   385

        {

   386

            "bitmap":    "ImportSVG",

   387

            "name":    _("Import SVG"),

   388

            "tooltip": _("Import SVG"),

   389

            "method":   "_ImportSVG"

   390

        },

   391

        {

   392

            "bitmap":    "ImportSVG",  # should be something different

   393

            "name":    _("Inkscape"),

   394

            "tooltip": _("Edit HMI"),

   395

            "method":   "_StartInkscape"

   396

        },

   397

   398

        # TODO : Launch POEdit button

   399

        #        PO -> SVG layers button

   400

        #        SVG layers -> PO

   401

   402

        # TODO : HMITree button

   403

        #        - can drag'n'drop variabes to Inkscape

   404

   405

    ]

   406

   407

    def _getSVGpath(self, project_path=None):

   408

        if project_path is None:

   409

            project_path = self.CTNPath()

   410

        return os.path.join(project_path, "svghmi.svg")

   411

   412

   413

    def OnCTNSave(self, from_project_path=None):

   414

        if from_project_path is not None:

   415

            shutil.copyfile(self._getSVGpath(from_project_path),

   416

                            self._getSVGpath())

   417

        return True

   418

   419

    def GetSVGGeometry(self):

   420

        # invoke inskscape -S, csv-parse output, produce elements

   421

        InkscapeGeomColumns = ["Id", "x", "y", "w", "h"]

   422

   423

        inkpath = get_inkscape_path()

   424

        svgpath = self._getSVGpath()

   425

        _status, result, _err_result = ProcessLogger(None,

   426

                                                     inkpath + " -S " + svgpath,

   427

                                                     no_stdout=True,

   428

                                                     no_stderr=True).spin()

   429

        res = []

   430

        for line in result.split():

   431

            strippedline = line.strip()

   432

            attrs = dict(

   433

                zip(InkscapeGeomColumns, line.strip().split(',')))

   434

   435

            res.append(etree.Element("bbox", **attrs))

   436

   437

        return res

   438

   439

    def GetHMITree(self):

   440

        global hmi_tree_root

   441

        res = [hmi_tree_root.etree(add_hash=True)]

   442

        return res

   443

   444

    def CTNGenerate_C(self, buildpath, locations):

   445

        """

   446

        Return C code generated by iec2c compiler

   447

        when _generate_softPLC have been called

   448

        @param locations: ignored

   449

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   450

        """

   451

   452

        location_str = "_".join(map(str, self.GetCurrentLocation()))

   453

        view_name = self.BaseParams.getName()

   454

   455

        svgfile = self._getSVGpath()

   456

   457

        res = ([], "", False)

   458

   459

        target_fname = "svghmi_"+location_str+".xhtml"

   460

   461

        target_path = os.path.join(self._getBuildPath(), target_fname)

   462

        target_file = open(target_path, 'wb')

   463

   464

        if os.path.exists(svgfile):

   465

   466

            # TODO : move to __init__

   467

            transform = XSLTransform(os.path.join(ScriptDirectory, "gen_index_xhtml.xslt"),

   468

                          [("GetSVGGeometry", lambda *_ignored:self.GetSVGGeometry()),

   469

                           ("GetHMITree", lambda *_ignored:self.GetHMITree())])

   470

   471

   472

            # load svg as a DOM with Etree

   473

            svgdom = etree.parse(svgfile)

   474

   475

            # call xslt transform on Inkscape's SVG to generate XHTML

   476

            try:

   477

                result = transform.transform(svgdom)

   478

            except XSLTApplyError as e:

   479

                self.FatalError("SVGHMI " + view_name  + ": " + e.message)

   480

   481

            result.write(target_file, encoding="utf-8")

   482

            # print(str(result))

   483

            # print(transform.xslt.error_log)

   484

   485

            # TODO

   486

            #   - Errors on HMI semantics

   487

            #   - ... maybe something to have a global view of what is declared in SVG.

   488

   489

        else:

   490

            # TODO : use default svg that expose the HMI tree as-is