1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz

     5

# Copyright (C) 2021: Edouard TISSERANT

     6

#

     7

# See COPYING file for copyrights details.

     8

     9

from __future__ import absolute_import

    10

import os

    11

import shutil

    12

import hashlib

    13

import shlex

    14

import time

    15

    16

import wx

    17

    18

from lxml import etree

    19

from lxml.etree import XSLTApplyError

    20

    21

import util.paths as paths

    22

from POULibrary import POULibrary

    23

from docutil import open_svg, get_inkscape_path

    24

    25

from util.ProcessLogger import ProcessLogger

    26

from runtime.typemapping import DebugTypesSize

    27

import targets

    28

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    29

from XSLTransform import XSLTransform

    30

from svghmi.i18n import EtreeToMessages, SaveCatalog, ReadTranslations,\

    31

                        MatchTranslations, TranslationToEtree, open_pofile,\

    32

                        GetPoFiles

    33

from svghmi.hmi_tree import HMI_TYPES, HMITreeNode, SPECIAL_NODES 

    34

from svghmi.ui import SVGHMI_UI

    35

from svghmi.fonts import GetFontTypeAndFamilyName, GetCSSFontFaceFromFontFile

    36

    37

    38

ScriptDirectory = paths.AbsDir(__file__)

    39

    40

    41

# module scope for HMITree root

    42

# so that CTN can use HMITree deduced in Library

    43

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

    44

#       systematicaly invoked before CTN's CTNGenerate_C

    45

    46

hmi_tree_root = None

    47

    48

on_hmitree_update = None

    49

    50

class SVGHMILibrary(POULibrary):

    51

    def GetLibraryPath(self):

    52

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

    53

    54

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

    55

        global hmi_tree_root, on_hmitree_update

    56

    57

        """

    58

        PLC Instance Tree:

    59

          prog0

    60

           +->v1 HMI_INT

    61

           +->v2 HMI_INT

    62

           +->fb0 (type mhoo)

    63

           |   +->va HMI_NODE

    64

           |   +->v3 HMI_INT

    65

           |   +->v4 HMI_INT

    66

           |

    67

           +->fb1 (type mhoo)

    68

           |   +->va HMI_NODE

    69

           |   +->v3 HMI_INT

    70

           |   +->v4 HMI_INT

    71

           |

    72

           +->fb2

    73

               +->v5 HMI_IN

    74

    75

        HMI tree:

    76

          hmi0

    77

           +->v1

    78

           +->v2

    79

           +->fb0 class:va

    80

           |   +-> v3

    81

           |   +-> v4

    82

           |

    83

           +->fb1 class:va

    84

           |   +-> v3

    85

           |   +-> v4

    86

           |

    87

           +->v5

    88

    89

        """

    90

    91

        # Filter known HMI types

    92

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

    93

    94

        hmi_tree_root = None

    95

    96

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

    97

        for i,v in enumerate(hmi_types_instances):

    98

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

    99

            derived = v["derived"]

   100

            if derived == "HMI_NODE":

   101

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

   102

                hmi_types_instances.pop(i)

   103

                break

   104

   105

        if hmi_tree_root is None:

   106

            self.FatalError("SVGHMI : Library is selected but not used. Please either deselect it in project config or add a SVGHMI node to project.")

   107

   108

        # deduce HMI tree from PLC HMI_* instances

   109

        for v in hmi_types_instances:

   110

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

   111

            # ignores variables starting with _TMP_

   112

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

   113

                continue

   114

            derived = v["derived"]

   115

            kwargs={}

   116

            if derived == "HMI_NODE":

   117

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

   118

                name = path[-2]

   119

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

   120

            else:

   121

                name = path[-1]

   122

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

   123

            placement_result = hmi_tree_root.place_node(new_node)

   124

            if placement_result is not None:

   125

                cause, problematic_node = placement_result

   126

                if cause == "Non_Unique":

   127

                    message = _("HMI tree nodes paths are not unique.\nConflicting variable: {} {}").format(

   128

                        ".".join(problematic_node.path),

   129

                        ".".join(new_node.path))

   130

   131

                    last_FB = None 

   132

                    for v in varlist:

   133

                        if v["vartype"] == "FB":

   134

                            last_FB = v 

   135

                        if v["C_path"] == problematic_node:

   136

                            break

   137

                    if last_FB is not None:

   138

                        failing_parent = last_FB["type"]

   139

                        message += "\n"

   140

                        message += _("Solution: Add HMI_NODE at beginning of {}").format(failing_parent)

   141

   142

                elif cause in ["Late_HMI_NODE", "Duplicate_HMI_NODE"]:

   143

                    cause, problematic_node = placement_result

   144

                    message = _("There must be only one occurrence of HMI_NODE before any HMI_* variable in POU.\nConflicting variable: {} {}").format(

   145

                        ".".join(problematic_node.path),

   146

                        ".".join(new_node.path))

   147

   148

                self.FatalError("SVGHMI : " + message)

   149

   150

        if on_hmitree_update is not None:

   151

            on_hmitree_update(hmi_tree_root)

   152

   153

        variable_decl_array = []

   154

        extern_variables_declarations = []

   155

        buf_index = 0

   156

        item_count = 0

   157

        found_heartbeat = False

   158

   159

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   160

   161

        for node in hmi_tree_root.traverse():

   162

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   163

                hmi_tree_hearbeat_index = item_count

   164

                found_heartbeat = True

   165

                extern_variables_declarations += [

   166

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   167

                ]

   168

            if hasattr(node, "iectype"):

   169

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

   170

                variable_decl_array += [

   171

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

   172

                        "EXT": "_P_ENUM",

   173

                        "IN":  "_P_ENUM",

   174

                        "MEM": "_O_ENUM",

   175

                        "OUT": "_O_ENUM",

   176

                        "VAR": "_ENUM"

   177

                    }[node.vartype] + ", " +

   178

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

   179

                buf_index += sz

   180

                item_count += 1

   181

                if len(node.path) == 1:

   182

                    extern_variables_declarations += [

   183

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

   184

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

   185

                        + node.cpath + ";"]

   186

   187

        assert(found_heartbeat)

   188

   189

        # TODO : filter only requiered external declarations

   190

        for v in varlist:

   191

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

   192

                extern_variables_declarations += [

   193

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

   194

   195

        # TODO check if programs need to be declared separately

   196

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

   197

        #                                     p for p in self._ProgramList]),

   198

   199

        # C code to observe/access HMI tree variables

   200

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

   201

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   202

        svghmi_c_code = svghmi_c_file.read()

   203

        svghmi_c_file.close()

   204

        svghmi_c_code = svghmi_c_code % {

   205

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

   206

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

   207

            "buffer_size": buf_index,

   208

            "item_count": item_count,

   209

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

   210

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

   211

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

   212

            }

   213

   214

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

   215

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   216

        gen_svghmi_c.write(svghmi_c_code)

   217

        gen_svghmi_c.close()

   218

   219

        # Python based WebSocket HMITree Server

   220

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

   221

        svghmiservercode = svghmiserverfile.read()

   222

        svghmiserverfile.close()

   223

   224

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

   225

        runtimefile = open(runtimefile_path, 'w')

   226

        runtimefile.write(svghmiservercode)

   227

        runtimefile.close()

   228

   229

        # Backup HMI Tree in XML form so that it can be loaded without building

   230

        hmitree_backup_path = os.path.join(buildpath, "hmitree.xml")

   231

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   232

        hmitree_backup_file.write(etree.tostring(hmi_tree_root.etree()))

   233

        hmitree_backup_file.close()

   234

   235

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

   236

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

   237

                #         ^

   238

                # note the double zero after "runtime_", 

   239

                # to ensure placement before other CTN generated code in execution order

   240

   241

   242

def Register_SVGHMI_UI_for_HMI_tree_updates(ref):

   243

    global on_hmitree_update

   244

    def HMITreeUpdate(_hmi_tree_root):

   245

        obj = ref()

   246

        if obj is not None:

   247

            obj.HMITreeUpdate(_hmi_tree_root)

   248

   249

    on_hmitree_update = HMITreeUpdate

   250

   251

   252

class SVGHMIEditor(ConfTreeNodeEditor):

   253

    CONFNODEEDITOR_TABS = [

   254

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

   255

   256

    def CreateSVGHMI_UI(self, parent):

   257

        global hmi_tree_root

   258

   259

        if hmi_tree_root is None:

   260

            buildpath = self.Controler.GetCTRoot()._getBuildPath()

   261

            hmitree_backup_path = os.path.join(buildpath, "hmitree.xml")

   262

            if os.path.exists(hmitree_backup_path):

   263

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   264

                hmi_tree_root = HMITreeNode.from_etree(etree.parse(hmitree_backup_file).getroot())

   265

   266

        ret = SVGHMI_UI(parent, Register_SVGHMI_UI_for_HMI_tree_updates)

   267

   268

        on_hmitree_update(hmi_tree_root)

   269

   270

        return ret

   271

   272

class SVGHMI(object):

   273

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

   274

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

   275

      <xsd:element name="SVGHMI">

   276

        <xsd:complexType>

   277

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

   278

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

   279

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

   280

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

   281

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

   282

        </xsd:complexType>

   283

      </xsd:element>

   284

    </xsd:schema>

   285

    """

   286

   287

    EditorType = SVGHMIEditor

   288

   289

    ConfNodeMethods = [

   290

        {

   291

            "bitmap":    "ImportSVG",

   292

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

   293

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

   294

            "method":   "_ImportSVG"

   295

        },

   296

        {

   297

            "bitmap":    "EditSVG",

   298

            "name":    _("Inkscape"),

   299

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

   300

            "method":   "_StartInkscape"

   301

        },

   302

        {

   303

            "bitmap":    "OpenPOT",

   304

            "name":    _("New lang"),

   305

            "tooltip": _("Open non translated message catalog (POT) to start new language"),

   306

            "method":   "_OpenPOT"

   307

        },

   308

        {

   309

            "bitmap":    "EditPO",

   310

            "name":    _("Edit lang"),

   311

            "tooltip": _("Edit existing message catalog (PO) for specific language"),

   312

            "method":   "_EditPO"

   313

        },

   314

        {

   315

            "bitmap":    "AddFont",

   316

            "name":    _("Add Font"),

   317

            "tooltip": _("Add TTF, OTF or WOFF font to be embedded in HMI"),

   318

            "method":   "_AddFont"

   319

        },

   320

        {

   321

            "bitmap":    "DelFont",

   322

            "name":    _("Delete Font"),

   323

            "tooltip": _("Remove font previously added to HMI"),

   324

            "method":   "_DelFont"

   325

        },

   326

    ]

   327

   328

    def _getSVGpath(self, project_path=None):

   329

        if project_path is None:

   330

            project_path = self.CTNPath()

   331

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

   332

   333

    def _getPOTpath(self, project_path=None):

   334

        if project_path is None:

   335

            project_path = self.CTNPath()

   336

        return os.path.join(project_path, "messages.pot")

   337

   338

    def OnCTNSave(self, from_project_path=None):

   339

        if from_project_path is not None:

   340

            shutil.copyfile(self._getSVGpath(from_project_path),

   341

                            self._getSVGpath())

   342

            shutil.copyfile(self._getPOTpath(from_project_path),

   343

                            self._getPOTpath())

   344

            # XXX TODO copy .PO files

   345

        return True

   346

   347

    def GetSVGGeometry(self):

   348

        self.ProgressStart("inkscape", "collecting SVG geometry (Inkscape)")

   349

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

   350

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

   351

   352

        inkpath = get_inkscape_path()

   353

   354

        if inkpath is None:

   355

            self.FatalError("SVGHMI: inkscape is not installed.")

   356

   357

        svgpath = self._getSVGpath()

   358

        status, result, _err_result = ProcessLogger(self.GetCTRoot().logger,

   359

                                                     '"' + inkpath + '" -S "' + svgpath + '"',

   360

                                                     no_stdout=True,

   361

                                                     no_stderr=True).spin()

   362

        if status != 0:

   363

            self.FatalError("SVGHMI: inkscape couldn't extract geometry from given SVG.")

   364

   365

        res = []

   366

        for line in result.split():

   367

            strippedline = line.strip()

   368

            attrs = dict(

   369

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

   370

   371

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

   372

   373

        self.ProgressEnd("inkscape")

   374

        return res

   375

   376

    def GetHMITree(self):

   377

        global hmi_tree_root

   378

        self.ProgressStart("hmitree", "getting HMI tree")

   379

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

   380

        self.ProgressEnd("hmitree")

   381

        return res

   382

   383

    def GetTranslations(self, _context, msgs):

   384

        self.ProgressStart("i18n", "getting Translations")

   385

        messages = EtreeToMessages(msgs)

   386

   387

        if len(messages) == 0:

   388

            self.ProgressEnd("i18n")

   389

            return

   390

   391

        SaveCatalog(self._getPOTpath(), messages)

   392

   393

        translations = ReadTranslations(self.CTNPath())

   394

   395

        langs,translated_messages = MatchTranslations(translations, messages, 

   396

            errcallback=self.GetCTRoot().logger.write_warning)

   397

   398

        ret = TranslationToEtree(langs,translated_messages)

   399

   400

        self.ProgressEnd("i18n")

   401

   402

        return ret

   403

   404

    def GetFontsFiles(self):

   405

        project_path = self.CTNPath()

   406

        fontdir = os.path.join(project_path, "fonts") 

   407

        if os.path.isdir(fontdir):

   408

            return [os.path.join(fontdir,f) for f in sorted(os.listdir(fontdir))]

   409

        return []

   410

   411

    def GetFonts(self, _context):

   412

        css_parts = []

   413

   414

        for fontfile in self.GetFontsFiles():

   415

            if os.path.isfile(fontfile):

   416

                css_parts.append(GetCSSFontFaceFromFontFile(fontfile))

   417

   418

        return "".join(css_parts)

   419

   420

    times_msgs = {}

   421

    indent = 1

   422

    def ProgressStart(self, k, m):

   423

        self.times_msgs[k] = (time.time(), m)

   424

        self.GetCTRoot().logger.write("    "*self.indent + "Start %s...\n"%m)

   425

        self.indent = self.indent + 1

   426

   427

    def ProgressEnd(self, k):

   428

        t = time.time()

   429

        oldt, m = self.times_msgs[k]

   430

        self.indent = self.indent - 1

   431

        self.GetCTRoot().logger.write("    "*self.indent + "... finished in %.3fs\n"%(t - oldt))

   432

   433

    def CTNGenerate_C(self, buildpath, locations):

   434

   435

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

   436

        view_name = self.BaseParams.getName()

   437

   438

        svgfile = self._getSVGpath()

   439

   440

        res = ([], "", False)

   441

   442

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

   443

   444

        build_path = self._getBuildPath()

   445

        target_path = os.path.join(build_path, target_fname)

   446

        hash_path = os.path.join(build_path, "svghmi.md5")

   447

   448

        self.GetCTRoot().logger.write("SVGHMI:\n")

   449

   450

        if os.path.exists(svgfile):

   451

   452

            hasher = hashlib.md5()

   453

            hmi_tree_root._hash(hasher)

   454

            pofiles = GetPoFiles(self.CTNPath())

   455

            filestocheck = [svgfile] + \

   456

                           (list(zip(*pofiles)[1]) if pofiles else []) + \

   457

                           self.GetFontsFiles()

   458

   459

            for filetocheck in filestocheck:

   460

                with open(filetocheck, 'rb') as afile:

   461

                    while True:

   462

                        buf = afile.read(65536)

   463

                        if len(buf) > 0:

   464

                            hasher.update(buf)

   465

                        else:

   466

                            break

   467

            digest = hasher.hexdigest()

   468

   469

            if os.path.exists(hash_path):

   470

                with open(hash_path, 'rb') as digest_file:

   471

                    last_digest = digest_file.read()

   472

            else:

   473

                last_digest = None

   474

   475

            if digest != last_digest:

   476

   477

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

   478

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

   479

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

   480

                               ("GetTranslations", self.GetTranslations),

   481

                               ("GetFonts", self.GetFonts),

   482

                               ("ProgressStart", lambda _ign,k,m:self.ProgressStart(str(k),str(m))),

   483

                               ("ProgressEnd", lambda _ign,k:self.ProgressEnd(str(k)))])

   484

   485

                self.ProgressStart("svg", "source SVG parsing")

   486

   487

                # load svg as a DOM with Etree

   488