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

    14

import hashlib

    15

import weakref

    16

    17

import wx

    18

import wx.dataview as dv

    19

    20

from lxml import etree

    21

from lxml.etree import XSLTApplyError

    22

    23

import util.paths as paths

    24

from POULibrary import POULibrary

    25

from docutil import open_svg, get_inkscape_path

    26

    27

from util.ProcessLogger import ProcessLogger

    28

from runtime.typemapping import DebugTypesSize

    29

import targets

    30

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    31

from XSLTransform import XSLTransform

    32

    33

HMI_TYPES_DESC = {

    34

    "HMI_NODE":{},

    35

    "HMI_STRING":{},

    36

    "HMI_INT":{},

    37

    "HMI_REAL":{}

    38

}

    39

    40

HMI_TYPES = HMI_TYPES_DESC.keys()

    41

    42

    43

ScriptDirectory = paths.AbsDir(__file__)

    44

    45

class HMITreeNode(object):

    47

        self.path = path

    48

        self.name = name

    49

        self.nodetype = nodetype

    50

        self.hmiclass = hmiclass

    51

    52

        if iectype is not None:

    53

            self.iectype = iectype

    54

            self.vartype = vartype

    57

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

    58

            self.children = []

    59

    60

    def pprint(self, indent = 0):

    61

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

    62

        if hasattr(self, "children"):

    63

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

    64

                              for child in self.children])

    65

            res += "\n"

    66

    67

        return res

    68

    69

    def place_node(self, node):

    70

        best_child = None

    71

        known_best_match = 0

    72

        for child in self.children:

    73

            if child.path is not None:

    74

                in_common = 0

    75

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

    76

                    if child_path_item == node_path_item:

    77

                        in_common +=1

    78

                    else:

    79

                        break

    80

                if in_common > known_best_match:

    81

                    known_best_match = in_common

    82

                    best_child = child

    83

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

    84

            best_child.place_node(node)

    85

        else:

    86

            self.children.append(node)

    87

    88

    def etree(self, add_hash=False):

    89

    90

        attribs = dict(name=self.name)

    91

        if self.path is not None:

    92

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

    93

    94

        if self.hmiclass is not None:

    95

            attribs["class"] = self.hmiclass

    96

    97

        if add_hash:

    98

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

    99

   100

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

   101

   102

        if hasattr(self, "children"):

   103

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

   104

                res.append(child_etree)

   105

   106

        return res

   107

   108

    def traverse(self):

   109

        yield self

   110

        if hasattr(self, "children"):

   111

            for c in self.children:

   112

                for yoodl in c.traverse():

   113

                    yield yoodl

   114

   115

   116

    def hash(self):

   117

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

   118

        s = hashlib.new('md5')

   119

        self._hash(s)

   120

        # limit size to HMI_HASH_SIZE as in svghmi.c

   121

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

   122

   123

    def _hash(self, s):

   124

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

   125

        if hasattr(self, "children"):

   126

            for c in self.children:

   127

                c._hash(s)

   128

   129

# module scope for HMITree root

   130

# so that CTN can use HMITree deduced in Library

   131

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

   132

#       systematicaly invoked before CTN's CTNGenerate_C

   133

   134

hmi_tree_root = None

   135

   136

on_hmitree_update = None

   137

   141

class SVGHMILibrary(POULibrary):

   142

    def GetLibraryPath(self):

   143

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

   144

   145

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

   147

   148

        """

   149

        PLC Instance Tree:

   150

          prog0

   151

           +->v1 HMI_INT

   152

           +->v2 HMI_INT

   153

           +->fb0 (type mhoo)

   154

           |   +->va HMI_NODE

   155

           |   +->v3 HMI_INT

   156

           |   +->v4 HMI_INT

   157

           |

   158

           +->fb1 (type mhoo)

   159

           |   +->va HMI_NODE

   160

           |   +->v3 HMI_INT

   161

           |   +->v4 HMI_INT

   162

           |

   163

           +->fb2

   164

               +->v5 HMI_IN

   165

   166

        HMI tree:

   167

          hmi0

   168

           +->v1

   169

           +->v2

   170

           +->fb0 class:va

   171

           |   +-> v3

   172

           |   +-> v4

   173

           |

   174

           +->fb1 class:va

   175

           |   +-> v3

   176

           |   +-> v4

   177

           |

   178

           +->v5

   179

   180

        """

   181

   182

        # Filter known HMI types

   183

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

   184

   185

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

   186

   187

        # deduce HMI tree from PLC HMI_* instances

   188

        for v in hmi_types_instances:

   190

            # ignores variables starting with _TMP_

   191

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

   192

                continue

   193

            derived = v["derived"]

   194

            kwargs={}

   195

            if derived == "HMI_NODE":

   197

                name = path[-2]

   198

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

   199

            else:

   200

                name = path[-1]

   202

            hmi_tree_root.place_node(new_node)

   203

   204

        if on_hmitree_update is not None:

   205

            on_hmitree_update()

   206

   207

        variable_decl_array = []

   208

        extern_variables_declarations = []

   209

        buf_index = 0

   210

        item_count = 0

   217

        for node in hmi_tree_root.traverse():

   228

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

   229

                variable_decl_array += [

   231

                        "EXT": "_P_ENUM",

   232

                        "IN":  "_P_ENUM",

   233

                        "MEM": "_O_ENUM",

   234

                        "OUT": "_O_ENUM",

   235

                        "VAR": "_ENUM"

   236

                    }[node.vartype] + ", " +

   237

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

   238

                buf_index += sz

   239

                item_count += 1

   240

                if len(node.path) == 1:

   241

                    extern_variables_declarations += [

   242

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

   243

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

   247

   248

        # TODO : filter only requiered external declarations

   249

        for v in varlist :

   251

                extern_variables_declarations += [

   252

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

   253

   254

        # TODO check if programs need to be declared separately

   255

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

   256

        #                                     p for p in self._ProgramList]),

   257

   258

        # C code to observe/access HMI tree variables

   259

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

   260

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   261

        svghmi_c_code = svghmi_c_file.read()

   262

        svghmi_c_file.close()

   263

        svghmi_c_code = svghmi_c_code % {

   264

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

   265

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

   266

            "buffer_size": buf_index,

   267

            "item_count": item_count,

   268

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

   269

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

   270

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

   271

            }

   272

   273

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

   274

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   275

        gen_svghmi_c.write(svghmi_c_code)

   276

        gen_svghmi_c.close()

   277

   278

        # Python based WebSocket HMITree Server

   279

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

   280

        svghmiservercode = svghmiserverfile.read()

   281

        svghmiserverfile.close()

   282

   283

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

   284

        runtimefile = open(runtimefile_path, 'w')

   285

        runtimefile.write(svghmiservercode)

   286

        runtimefile.close()

   287

   288

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

   289

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

   290

   291

   292

class HMITreeSelector(wx.TreeCtrl):

   293

    def __init__(self, parent):

   294

        global on_hmitree_update

   295

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

   296

   297

        isz = (16,16)

   298

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

   299

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

   300

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

   301

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

   302

        self.SetImageList(il)

   303

   304

        on_hmitree_update = self.SVGHMIEditorUpdater()

   305

        self.MakeTree()

   306

   307

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   308

        for c in current_hmitree_root.children:

   309

            if hasattr(c, "children"):

   310

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

   311

                               if c.hmiclass is not None else c.name

   312

                tc_child = self.AppendItem(current_tc_root, display_name)

   313

                self.SetPyData(tc_child, None)

   314

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

   315

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

   316

   317

                self._recurseTree(c,tc_child)

   318

            else:

   319

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

   320

                tc_child = self.AppendItem(current_tc_root, display_name)

   321

                self.SetPyData(tc_child, None)

   322

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

   323

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

   324

   325

    def MakeTree(self):

   326

        global hmi_tree_root

   327

   328

        self.Freeze()

   329

   330

        self.root = None

   331

        self.DeleteAllItems()

   332

   333

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

   334

        self.root = self.AddRoot(root_display_name)

   335

        self.SetPyData(self.root, None)

   336

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

   337

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

   338

   339

        if hmi_tree_root is not None:

   340

            self._recurseTree(hmi_tree_root, self.root)

   341

   342

        self.Thaw()

   343

   344

    def SVGHMIEditorUpdater(self):

   345

        selfref = weakref.ref(self)

   346

        def SVGHMIEditorUpdate():

   347

            o = selfref()

   348

            if o is not None:

   349

                wx.CallAfter(o.MakeTree)

   350

        return SVGHMIEditorUpdate

   351

   352

class HMITreeView(wx.SplitterWindow):

   353

   354

    def __init__(self, parent):

   355

        wx.SplitterWindow.__init__(self, parent,

   356

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   357

   358

        self.SelectionTree = HMITreeSelector(self)

   359

        #self.Staging = wx.Panel(self)

   360

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

   361

        self.Initialize(self.SelectionTree)

   362

   363

   364

class SVGHMIEditor(ConfTreeNodeEditor):

   365

    CONFNODEEDITOR_TABS = [

   366

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

   367

   368

    def CreateHMITreeView(self, parent):

   369

        #self.HMITreeView = HMITreeView(self)

   370

        return HMITreeSelector(parent)

   371

   372

   373

class SVGHMI(object):

   374

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

   375

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

   376

      <xsd:element name="SVGHMI">

   377

        <xsd:complexType>

   378

          <xsd:attribute name="enableHTTP" type="xsd:boolean" use="optional" default="false"/>

   379

          <xsd:attribute name="bindAddress" type="xsd:string" use="optional" default="localhost"/>

   380

          <xsd:attribute name="port" type="xsd:string" use="optional" default="8080"/>

   381

        </xsd:complexType>

   382

      </xsd:element>

   383

    </xsd:schema>

   384

    """

   385

   386

    EditorType = SVGHMIEditor

   387

   388

    ConfNodeMethods = [

   389

        {

   390

            "bitmap":    "ImportSVG",

   391

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

   392

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

   393

            "method":   "_ImportSVG"

   394

        },

   395

        {

   396

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

   397

            "name":    _("Inkscape"),

   398

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

   399

            "method":   "_StartInkscape"

   400

        },

   401

   402

        # TODO : Launch POEdit button

   403

        #        PO -> SVG layers button

   404

        #        SVG layers -> PO

   405

   406

        # TODO : HMITree button

   407

        #        - can drag'n'drop variabes to Inkscape

   408

   409

    ]

   410

   411

    def _getSVGpath(self, project_path=None):

   412

        if project_path is None:

   413

            project_path = self.CTNPath()

   414

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

   415

   416

   417

    def OnCTNSave(self, from_project_path=None):

   418

        if from_project_path is not None:

   419

            shutil.copyfile(self._getSVGpath(from_project_path),

   420

                            self._getSVGpath())

   421

        return True

   422

   423

    def GetSVGGeometry(self):

   424

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

   425

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

   426

   427

        inkpath = get_inkscape_path()

   428

        svgpath = self._getSVGpath()

   429

        _status, result, _err_result = ProcessLogger(None,

   430

                                                     inkpath + " -S " + svgpath,

   431

                                                     no_stdout=True,

   432

                                                     no_stderr=True).spin()

   433

        res = []

   434

        for line in result.split():

   435

            strippedline = line.strip()

   436

            attrs = dict(

   437

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

   438

   439

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

   440

   441

        return res

   442

   443

    def GetHMITree(self):

   444

        global hmi_tree_root

   445

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

   446

        return res

   447

   448

    def CTNGenerate_C(self, buildpath, locations):

   449

        """

   450

        Return C code generated by iec2c compiler

   451

        when _generate_softPLC have been called

   452

        @param locations: ignored

   453

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

   454

        """

   455

   456

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

   457

        view_name = self.BaseParams.getName()

   458

   459

        svgfile = self._getSVGpath()

   460

   461

        res = ([], "", False)

   462

   463

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

   464

   465

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

   466

        target_file = open(target_path, 'wb')

   467

   468

        if os.path.exists(svgfile):

   469

   470

            # TODO : move to __init__

   471

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

   472

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

   473

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

   474

   475

   476

            # load svg as a DOM with Etree

   477

            svgdom = etree.parse(svgfile)

   478

   479

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

   480

            try:

   481

                result = transform.transform(svgdom)

   482

            except XSLTApplyError as e:

   483

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

   484

   485

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

   486

            # print(str(result))

   487

            # print(transform.xslt.error_log)

   488

   489

            # TODO

   490

            #   - Errors on HMI semantics

   491