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

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

    82

                # must match candidate node (except for name part)

    83

                # since candidate would become child of that node

    84

                if in_common > known_best_match and \

    85

                   child.nodetype == "HMI_NODE" and \

    86

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

    87

                    known_best_match = in_common

    88

                    best_child = child

    89

        if best_child is not None:

    90

            best_child.place_node(node)

    91

        else:

    92

            self.children.append(node)

    93

    94

    def etree(self, add_hash=False):

    95

    96

        attribs = dict(name=self.name)

    97

        if self.path is not None:

    98

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

    99

   100

        if self.hmiclass is not None:

   101

            attribs["class"] = self.hmiclass

   102

   103

        if add_hash:

   104

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

   105

   106

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

   107

   108

        if hasattr(self, "children"):

   109

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

   110

                res.append(child_etree)

   111

   112

        return res

   113

   114

    def traverse(self):

   115

        yield self

   116

        if hasattr(self, "children"):

   117

            for c in self.children:

   118

                for yoodl in c.traverse():

   119

                    yield yoodl

   120

   121

   122

    def hash(self):

   123

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

   124

        s = hashlib.new('md5')

   125

        self._hash(s)

   126

        # limit size to HMI_HASH_SIZE as in svghmi.c

   127

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

   128

   129

    def _hash(self, s):

   130

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

   131

        if hasattr(self, "children"):

   132

            for c in self.children:

   133

                c._hash(s)

   134

   135

# module scope for HMITree root

   136

# so that CTN can use HMITree deduced in Library

   137

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

   138

#       systematicaly invoked before CTN's CTNGenerate_C

   139

   140

hmi_tree_root = None

   141

   142

on_hmitree_update = None

   143

   144

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

   145

                 ("heartbeat", "HMI_INT")]

   146

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

   147

   148

class SVGHMILibrary(POULibrary):

   149

    def GetLibraryPath(self):

   150

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

   151

   152

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

   153

        global hmi_tree_root, on_hmitree_update

   154

   155

        """

   156

        PLC Instance Tree:

   157

          prog0

   158

           +->v1 HMI_INT

   159

           +->v2 HMI_INT

   160

           +->fb0 (type mhoo)

   161

           |   +->va HMI_NODE

   162

           |   +->v3 HMI_INT

   163

           |   +->v4 HMI_INT

   164

           |

   165

           +->fb1 (type mhoo)

   166

           |   +->va HMI_NODE

   167

           |   +->v3 HMI_INT

   168

           |   +->v4 HMI_INT

   169

           |

   170

           +->fb2

   171

               +->v5 HMI_IN

   172

   173

        HMI tree:

   174

          hmi0

   175

           +->v1

   176

           +->v2

   177

           +->fb0 class:va

   178

           |   +-> v3

   179

           |   +-> v4

   180

           |

   181

           +->fb1 class:va

   182

           |   +-> v3

   183

           |   +-> v4

   184

           |

   185

           +->v5

   186

   187

        """

   188

   189

        # Filter known HMI types

   190

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

   191

   192

        hmi_tree_root = None

   193

   194

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

   195

        for i,v in enumerate(hmi_types_instances):

   196

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

   197

            derived = v["derived"]

   198

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

   199

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

   200

                hmi_types_instances.pop(i)

   201

                break

   202

   203

        assert(hmi_tree_root is not None)

   204

   205

        # deduce HMI tree from PLC HMI_* instances

   206

        for v in hmi_types_instances:

   207

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

   208

            # ignores variables starting with _TMP_

   209

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

   210

                continue

   211

            derived = v["derived"]

   212

            kwargs={}

   213

            if derived == "HMI_NODE":

   214

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

   215

                name = path[-2]

   216

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

   217

            else:

   218

                name = path[-1]

   219

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

   220

            hmi_tree_root.place_node(new_node)

   221

   222

        if on_hmitree_update is not None:

   223

            on_hmitree_update()

   224

   225

        variable_decl_array = []

   226

        extern_variables_declarations = []

   227

        buf_index = 0

   228

        item_count = 0

   229

        found_heartbeat = False

   230

   231

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   232

   233

        for node in hmi_tree_root.traverse():

   234

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   235

                hmi_tree_hearbeat_index = item_count

   236

                found_heartbeat = True

   237

                extern_variables_declarations += [

   238

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   239

                ]

   240

            if hasattr(node, "iectype"):

   241

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

   242

                variable_decl_array += [

   243

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

   244

                        "EXT": "_P_ENUM",

   245

                        "IN":  "_P_ENUM",

   246

                        "MEM": "_O_ENUM",

   247

                        "OUT": "_O_ENUM",

   248

                        "VAR": "_ENUM"

   249

                    }[node.vartype] + ", " +

   250

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

   251

                buf_index += sz

   252

                item_count += 1

   253

                if len(node.path) == 1:

   254

                    extern_variables_declarations += [

   255

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

   256

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

   257

                        + node.cpath + ";"]

   258

   259

        assert(found_heartbeat)

   260

   261

        # TODO : filter only requiered external declarations

   262

        for v in varlist:

   263

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

   264

                extern_variables_declarations += [

   265

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

   266

   267

        # TODO check if programs need to be declared separately

   268

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

   269

        #                                     p for p in self._ProgramList]),

   270

   271

        # C code to observe/access HMI tree variables

   272

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

   273

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   274

        svghmi_c_code = svghmi_c_file.read()

   275

        svghmi_c_file.close()

   276

        svghmi_c_code = svghmi_c_code % {

   277

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

   278

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

   279

            "buffer_size": buf_index,

   280

            "item_count": item_count,

   281

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

   282

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

   283

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

   284

            }

   285

   286

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

   287

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   288

        gen_svghmi_c.write(svghmi_c_code)

   289

        gen_svghmi_c.close()

   290

   291

        # Python based WebSocket HMITree Server

   292

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

   293

        svghmiservercode = svghmiserverfile.read()

   294

        svghmiserverfile.close()

   295

   296

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

   297

        runtimefile = open(runtimefile_path, 'w')

   298

        runtimefile.write(svghmiservercode)

   299

        runtimefile.close()

   300

   301

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

   302

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

   303

   304

   305

class HMITreeSelector(wx.TreeCtrl):

   306

    def __init__(self, parent):

   307

        global on_hmitree_update

   308

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

   309

   310

        isz = (16,16)

   311

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

   312

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

   313

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

   314

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

   315

        self.SetImageList(il)

   316

   317

        on_hmitree_update = self.SVGHMIEditorUpdater()

   318

        self.MakeTree()

   319

   320

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   321

        for c in current_hmitree_root.children:

   322

            if hasattr(c, "children"):

   323

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

   324

                               if c.hmiclass is not None else c.name

   325

                tc_child = self.AppendItem(current_tc_root, display_name)

   326

                self.SetPyData(tc_child, None)

   327

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

   328

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

   329

   330

                self._recurseTree(c,tc_child)

   331

            else:

   332

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

   333

                tc_child = self.AppendItem(current_tc_root, display_name)

   334

                self.SetPyData(tc_child, None)

   335

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

   336

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

   337

   338

    def MakeTree(self):

   339

        global hmi_tree_root

   340

   341

        self.Freeze()

   342

   343

        self.root = None

   344

        self.DeleteAllItems()

   345

   346

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

   347

        self.root = self.AddRoot(root_display_name)

   348

        self.SetPyData(self.root, None)

   349

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

   350

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

   351

   352

        if hmi_tree_root is not None:

   353

            self._recurseTree(hmi_tree_root, self.root)

   354

   355

        self.Thaw()

   356

   357

    def SVGHMIEditorUpdater(self):

   358

        selfref = weakref.ref(self)

   359

        def SVGHMIEditorUpdate():

   360

            o = selfref()

   361

            if o is not None:

   362

                wx.CallAfter(o.MakeTree)

   363

        return SVGHMIEditorUpdate

   364

   365

class HMITreeView(wx.SplitterWindow):

   366

   367

    def __init__(self, parent):

   368

        wx.SplitterWindow.__init__(self, parent,

   369

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   370

   371

        self.SelectionTree = HMITreeSelector(self)

   372

        #self.Staging = wx.Panel(self)

   373

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

   374

        self.Initialize(self.SelectionTree)

   375

   376

   377

class SVGHMIEditor(ConfTreeNodeEditor):

   378

    CONFNODEEDITOR_TABS = [

   379

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

   380

   381

    def CreateHMITreeView(self, parent):

   382

        #self.HMITreeView = HMITreeView(self)

   383

        return HMITreeSelector(parent)

   384

   385

   386

class SVGHMI(object):

   387

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

   388

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

   389

      <xsd:element name="SVGHMI">

   390

        <xsd:complexType>

   391

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

   392

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

   393

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

   394

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

   395

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

   396

        </xsd:complexType>

   397

      </xsd:element>

   398

    </xsd:schema>

   399

    """

   400

   401

    EditorType = SVGHMIEditor

   402

   403

    ConfNodeMethods = [

   404

        {

   405

            "bitmap":    "ImportSVG",

   406

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

   407

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

   408

            "method":   "_ImportSVG"

   409

        },

   410

        {

   411

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

   412

            "name":    _("Inkscape"),

   413

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

   414

            "method":   "_StartInkscape"

   415

        },

   416

   417

        # TODO : Launch POEdit button

   418

        #        PO -> SVG layers button

   419

        #        SVG layers -> PO

   420

   421

        # TODO : HMITree button

   422

        #        - can drag'n'drop variabes to Inkscape

   423

   424

    ]

   425

   426

    def _getSVGpath(self, project_path=None):

   427

        if project_path is None:

   428

            project_path = self.CTNPath()

   429

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

   430

   431

   432

    def OnCTNSave(self, from_project_path=None):

   433

        if from_project_path is not None:

   434

            shutil.copyfile(self._getSVGpath(from_project_path),

   435

                            self._getSVGpath())

   436

        return True

   437

   438

    def GetSVGGeometry(self):

   439

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

   440

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

   441

   442

        inkpath = get_inkscape_path()

   443

        svgpath = self._getSVGpath()

   444

        _status, result, _err_result = ProcessLogger(None,

   445

                                                     inkpath + " -S " + svgpath,

   446

                                                     no_stdout=True,

   447

                                                     no_stderr=True).spin()

   448

        res = []

   449

        for line in result.split():

   450

            strippedline = line.strip()

   451

            attrs = dict(

   452

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

   453

   454

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

   455

   456

        return res

   457

   458

    def GetHMITree(self):

   459

        global hmi_tree_root

   460

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

   461

        return res

   462

   463

    def CTNGenerate_C(self, buildpath, locations):

   464

   465

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

   466

        view_name = self.BaseParams.getName()

   467

   468

        svgfile = self._getSVGpath()

   469

   470

        res = ([], "", False)

   471

   472

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

   473

   474

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

   475

        target_file = open(target_path, 'wb')

   476

   477

        if os.path.exists(svgfile):

   478

   479

            # TODO : move to __init__

   480

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

   481

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

   482

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

   483

   484

   485

            # load svg as a DOM with Etree

   486

            svgdom = etree.parse(svgfile)

   487

   488

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

   489

            try: