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

                ]

   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:attribute name="WatchdogInitial" type="xsd:integer" use="optional"/>

   378

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

   379

        </xsd:complexType>

   380

      </xsd:element>

   381

    </xsd:schema>

   382

    """

   383

   384

    EditorType = SVGHMIEditor

   385

   386

    ConfNodeMethods = [

   387

        {

   388

            "bitmap":    "ImportSVG",

   389

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

   390

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

   391

            "method":   "_ImportSVG"

   392

        },

   393

        {

   394

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

   395

            "name":    _("Inkscape"),

   396

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

   397

            "method":   "_StartInkscape"

   398

        },

   399

   400

        # TODO : Launch POEdit button

   401

        #        PO -> SVG layers button

   402

        #        SVG layers -> PO

   403

   404

        # TODO : HMITree button

   405

        #        - can drag'n'drop variabes to Inkscape

   406

   407

    ]

   408

   409

    def _getSVGpath(self, project_path=None):

   410

        if project_path is None:

   411

            project_path = self.CTNPath()

   412

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

   413

   414

   415

    def OnCTNSave(self, from_project_path=None):

   416

        if from_project_path is not None:

   417

            shutil.copyfile(self._getSVGpath(from_project_path),

   418

                            self._getSVGpath())

   419

        return True

   420

   421

    def GetSVGGeometry(self):

   422

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

   423

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

   424

   425

        inkpath = get_inkscape_path()

   426

        svgpath = self._getSVGpath()

   427

        _status, result, _err_result = ProcessLogger(None,

   428

                                                     inkpath + " -S " + svgpath,

   429

                                                     no_stdout=True,

   430

                                                     no_stderr=True).spin()

   431

        res = []

   432

        for line in result.split():

   433

            strippedline = line.strip()

   434

            attrs = dict(

   435

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

   436

   437

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

   438

   439

        return res

   440

   441

    def GetHMITree(self):

   442

        global hmi_tree_root

   443

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

   444

        return res

   445

   446

    def CTNGenerate_C(self, buildpath, locations):

   447

        """

   448

        Return C code generated by iec2c compiler

   449

        when _generate_softPLC have been called

   450

        @param locations: ignored

   451

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

   452

        """

   453

   454

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

   455

        view_name = self.BaseParams.getName()

   456

   457

        svgfile = self._getSVGpath()

   458

   459

        res = ([], "", False)

   460

   461

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

   462

   463

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

   464

        target_file = open(target_path, 'wb')

   465

   466

        if os.path.exists(svgfile):

   467

   468

            # TODO : move to __init__

   469

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

   470

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

   471

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

   472

   473

   474

            # load svg as a DOM with Etree

   475

            svgdom = etree.parse(svgfile)

   476

   477

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

   478

            try: 

   479

                result = transform.transform(svgdom)

   480

            except XSLTApplyError as e:

   481

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

   482

            finally:

   483

                for entry in transform.get_error_log():

   484

                    message = "SVGHMI: "+ entry.message + "\n" 

   485

                    self.GetCTRoot().logger.write_warning(message)

   486

   487

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

   488

            # print(str(result))

   489

            # print(transform.xslt.error_log)

   490