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"]:

    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 = [("HMI_ROOT", "HMI_NODE"),

   140

                 ("heartbeat", "HMI_INT")]

   141

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

   142

   143

class SVGHMILibrary(POULibrary):

   144

    def GetLibraryPath(self):

   145

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

   146

   147

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

   148

        global hmi_tree_root, on_hmitree_update

   149

   150

        """

   151

        PLC Instance Tree:

   152

          prog0

   153

           +->v1 HMI_INT

   154

           +->v2 HMI_INT

   155

           +->fb0 (type mhoo)

   156

           |   +->va HMI_NODE

   157

           |   +->v3 HMI_INT

   158

           |   +->v4 HMI_INT

   159

           |

   160

           +->fb1 (type mhoo)

   161

           |   +->va HMI_NODE

   162

           |   +->v3 HMI_INT

   163

           |   +->v4 HMI_INT

   164

           |

   165

           +->fb2

   166

               +->v5 HMI_IN

   167

   168

        HMI tree:

   169

          hmi0

   170

           +->v1

   171

           +->v2

   172

           +->fb0 class:va

   173

           |   +-> v3

   174

           |   +-> v4

   175

           |

   176

           +->fb1 class:va

   177

           |   +-> v3

   178

           |   +-> v4

   179

           |

   180

           +->v5

   181

   182

        """

   183

   184

        # Filter known HMI types

   185

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

   186

   187

        hmi_tree_root = None

   188

   189

        # take first HMI_NODE (placed as special node), make it root

   190

        for i,v in enumerate(hmi_types_instances):

   191

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

   192

            derived = v["derived"]

   193

            if derived == "HMI_NODE" and ['CONFIG', 'HEARTBEAT'] :

   194

                hmi_tree_root = HMITreeNode(path, "", derived, v["type"], v["vartype"], v["C_path"])

   195

                hmi_types_instances.pop(i)

   196

                break

   197

   198

        assert(hmi_tree_root is not None)

   199

   200

        # deduce HMI tree from PLC HMI_* instances

   201

        for v in hmi_types_instances:

   202

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

   203

            # ignores variables starting with _TMP_

   204

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

   205

                continue

   206

            derived = v["derived"]

   207

            kwargs={}

   208

            if derived == "HMI_NODE":

   209

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

   210

                name = path[-2]

   211

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

   212

            else:

   213

                name = path[-1]

   214

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

   215

            hmi_tree_root.place_node(new_node)

   216

   217

        if on_hmitree_update is not None:

   218

            on_hmitree_update()

   219

   220

        variable_decl_array = []

   221

        extern_variables_declarations = []

   222

        buf_index = 0

   223

        item_count = 0

   224

        found_heartbeat = False

   225

   226

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   227

   228

        for node in hmi_tree_root.traverse():

   229

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   230

                hmi_tree_hearbeat_index = item_count

   231

                found_heartbeat = True

   232

                extern_variables_declarations += [

   233

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   234

                ]

   235

            if hasattr(node, "iectype"):

   236

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

   237

                variable_decl_array += [

   238

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

   239

                        "EXT": "_P_ENUM",

   240

                        "IN":  "_P_ENUM",

   241

                        "MEM": "_O_ENUM",

   242

                        "OUT": "_O_ENUM",

   243

                        "VAR": "_ENUM"

   244

                    }[node.vartype] + ", " +

   245

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

   246

                buf_index += sz

   247

                item_count += 1

   248

                if len(node.path) == 1:

   249

                    extern_variables_declarations += [

   250

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

   251

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

   252

                        + node.cpath + ";"]

   253

   254

        assert(found_heartbeat)

   255

   256

        # TODO : filter only requiered external declarations

   257

        for v in varlist:

   258

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

   259

                extern_variables_declarations += [

   260

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

   261

   262

        # TODO check if programs need to be declared separately

   263

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

   264

        #                                     p for p in self._ProgramList]),

   265

   266

        # C code to observe/access HMI tree variables

   267

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

   268

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   269

        svghmi_c_code = svghmi_c_file.read()

   270

        svghmi_c_file.close()

   271

        svghmi_c_code = svghmi_c_code % {

   272

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

   273

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

   274

            "buffer_size": buf_index,

   275

            "item_count": item_count,

   276

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

   277

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

   278

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

   279

            }

   280

   281

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

   282

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   283

        gen_svghmi_c.write(svghmi_c_code)

   284

        gen_svghmi_c.close()

   285

   286

        # Python based WebSocket HMITree Server

   287

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

   288

        svghmiservercode = svghmiserverfile.read()

   289

        svghmiserverfile.close()

   290

   291

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

   292

        runtimefile = open(runtimefile_path, 'w')

   293

        runtimefile.write(svghmiservercode)

   294

        runtimefile.close()

   295

   296

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

   297

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

   298

   299

   300

class HMITreeSelector(wx.TreeCtrl):

   301

    def __init__(self, parent):

   302

        global on_hmitree_update

   303

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

   304

   305

        isz = (16,16)

   306

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

   307

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

   308

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

   309

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

   310

        self.SetImageList(il)

   311

   312

        on_hmitree_update = self.SVGHMIEditorUpdater()

   313

        self.MakeTree()

   314

   315

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   316

        for c in current_hmitree_root.children:

   317

            if hasattr(c, "children"):

   318

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

   319

                               if c.hmiclass is not None else c.name

   320

                tc_child = self.AppendItem(current_tc_root, display_name)

   321

                self.SetPyData(tc_child, None)

   322

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

   323

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

   324

   325

                self._recurseTree(c,tc_child)

   326

            else:

   327

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

   328

                tc_child = self.AppendItem(current_tc_root, display_name)

   329

                self.SetPyData(tc_child, None)

   330

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

   331

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

   332

   333

    def MakeTree(self):

   334

        global hmi_tree_root

   335

   336

        self.Freeze()

   337

   338

        self.root = None

   339

        self.DeleteAllItems()

   340

   341

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

   342

        self.root = self.AddRoot(root_display_name)

   343

        self.SetPyData(self.root, None)

   344

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

   345

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

   346

   347

        if hmi_tree_root is not None:

   348

            self._recurseTree(hmi_tree_root, self.root)

   349

   350

        self.Thaw()

   351

   352

    def SVGHMIEditorUpdater(self):

   353

        selfref = weakref.ref(self)

   354

        def SVGHMIEditorUpdate():

   355

            o = selfref()

   356

            if o is not None:

   357

                wx.CallAfter(o.MakeTree)

   358

        return SVGHMIEditorUpdate

   359

   360

class HMITreeView(wx.SplitterWindow):

   361

   362

    def __init__(self, parent):

   363

        wx.SplitterWindow.__init__(self, parent,

   364

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   365

   366

        self.SelectionTree = HMITreeSelector(self)

   367

        #self.Staging = wx.Panel(self)

   368

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

   369

        self.Initialize(self.SelectionTree)

   370

   371

   372

class SVGHMIEditor(ConfTreeNodeEditor):

   373

    CONFNODEEDITOR_TABS = [

   374

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

   375

   376

    def CreateHMITreeView(self, parent):

   377

        #self.HMITreeView = HMITreeView(self)

   378

        return HMITreeSelector(parent)

   379

   380

   381

class SVGHMI(object):

   382

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

   383

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

   384

      <xsd:element name="SVGHMI">

   385

        <xsd:complexType>

   386

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

   387

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

   388

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

   389

          <xsd:attribute name="WatchdogInitial" type="xsd:integer" use="optional"/>

   390

          <xsd:attribute name="WatchdogInterval" type="xsd:integer" use="optional"/>

   391

        </xsd:complexType>

   392

      </xsd:element>

   393

    </xsd:schema>

   394

    """

   395

   396

    EditorType = SVGHMIEditor

   397

   398

    ConfNodeMethods = [

   399

        {

   400

            "bitmap":    "ImportSVG",

   401

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

   402

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

   403

            "method":   "_ImportSVG"

   404

        },

   405

        {

   406

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

   407

            "name":    _("Inkscape"),

   408

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

   409

            "method":   "_StartInkscape"

   410

        },

   411

   412

        # TODO : Launch POEdit button

   413

        #        PO -> SVG layers button

   414

        #        SVG layers -> PO

   415

   416

        # TODO : HMITree button

   417

        #        - can drag'n'drop variabes to Inkscape

   418

   419

    ]

   420

   421

    def _getSVGpath(self, project_path=None):

   422

        if project_path is None:

   423

            project_path = self.CTNPath()

   424

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

   425

   426

   427

    def OnCTNSave(self, from_project_path=None):

   428

        if from_project_path is not None:

   429

            shutil.copyfile(self._getSVGpath(from_project_path),

   430

                            self._getSVGpath())

   431

        return True

   432

   433

    def GetSVGGeometry(self):

   434

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

   435

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

   436

   437

        inkpath = get_inkscape_path()

   438

        svgpath = self._getSVGpath()

   439

        _status, result, _err_result = ProcessLogger(None,

   440

                                                     inkpath + " -S " + svgpath,

   441

                                                     no_stdout=True,

   442

                                                     no_stderr=True).spin()

   443

        res = []

   444

        for line in result.split():

   445

            strippedline = line.strip()

   446

            attrs = dict(

   447

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

   448

   449

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

   450

   451

        return res

   452

   453

    def GetHMITree(self):

   454

        global hmi_tree_root

   455

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

   456

        return res

   457

   458

    def CTNGenerate_C(self, buildpath, locations):

   459

   460

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

   461

        view_name = self.BaseParams.getName()

   462

   463

        svgfile = self._getSVGpath()

   464

   465

        res = ([], "", False)

   466

   467

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

   468

   469

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

   470

        target_file = open(target_path, 'wb')

   471

   472

        if os.path.exists(svgfile):

   473

   474

            # TODO : move to __init__

   475

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

   476

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

   477

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

   478

   479

   480

            # load svg as a DOM with Etree

   481

            svgdom = etree.parse(svgfile)

   482

   483

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

   484

            try: 

   485

                result = transform.transform(svgdom)

   486

            except XSLTApplyError as e:

   487

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

   488

            finally:

   489

                for entry in transform.get_error_log():