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

   246

   247

def Register_SVGHMI_UI_for_HMI_tree_updates(ref):

   248

    global on_hmitree_update

   249

    def HMITreeUpdate(_hmi_tree_root):

   250

        obj = ref()

   251

        if obj is not None:

   252

            obj.HMITreeUpdate(_hmi_tree_root)

   253

   254

    on_hmitree_update = HMITreeUpdate

   255

   256

   257

class SVGHMIEditor(ConfTreeNodeEditor):

   258

    CONFNODEEDITOR_TABS = [

   259

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

   260

   261

    def CreateSVGHMI_UI(self, parent):

   262

        global hmi_tree_root

   263

   264

        if hmi_tree_root is None:

   265

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

   266

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

   267

            if os.path.exists(hmitree_backup_path):

   268

                hmitree_backup_file = open(hmitree_backup_path, 'rb')

   269

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

   270

   271

        ret = SVGHMI_UI(parent, Register_SVGHMI_UI_for_HMI_tree_updates)

   272

   273

        on_hmitree_update(hmi_tree_root)

   274

   275

        return ret

   276

   277

class SVGHMI(object):

   278

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

   279

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

   280

      <xsd:element name="SVGHMI">

   281

        <xsd:complexType>

   282

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

   283

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

   284

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

   285

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

   286

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

   287

        </xsd:complexType>

   288

      </xsd:element>

   289

    </xsd:schema>

   290

    """

   291

   292

    EditorType = SVGHMIEditor

   293

   294

    ConfNodeMethods = [

   295

        {

   296

            "bitmap":    "ImportSVG",

   297

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

   298

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

   299

            "method":   "_ImportSVG"

   300

        },

   301

        {

   302

            "bitmap":    "EditSVG",

   303

            "name":    _("Inkscape"),

   304

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

   305

            "method":   "_StartInkscape"

   306

        },

   307

        {

   308

            "bitmap":    "OpenPOT",

   309

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

   310

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

   311

            "method":   "_OpenPOT"

   312

        },

   313

        {

   314

            "bitmap":    "EditPO",

   315

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

   316

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

   317

            "method":   "_EditPO"

   318

        },

   319

        {

   320

            "bitmap":    "AddFont",

   321

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

   322

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

   323

            "method":   "_AddFont"

   324

        },

   325

        {

   326

            "bitmap":    "DelFont",

   327

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

   328

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

   329

            "method":   "_DelFont"

   330

        },

   331

    ]

   332

   333

    def _getSVGpath(self, project_path=None):

   334

        if project_path is None:

   335

            project_path = self.CTNPath()

   336

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

   337

   338

    def _getPOTpath(self, project_path=None):

   339

        if project_path is None:

   340

            project_path = self.CTNPath()

   341

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

   342

   343

    def OnCTNSave(self, from_project_path=None):

   344

        if from_project_path is not None:

   345

            shutil.copyfile(self._getSVGpath(from_project_path),

   346

                            self._getSVGpath())

   347

            shutil.copyfile(self._getPOTpath(from_project_path),

   348

                            self._getPOTpath())

   349

            # XXX TODO copy .PO files

   350

        return True

   351

   352

    def GetSVGGeometry(self):

   353

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

   354

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

   355

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

   356

   357

        inkpath = get_inkscape_path()

   358

   359

        if inkpath is None:

   360

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

   361

   362

        svgpath = self._getSVGpath()

   363

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

   364

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

   365

                                                     no_stdout=True,

   366

                                                     no_stderr=True).spin()

   367

        if status != 0:

   368

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

   369

   370

        res = []

   371

        for line in result.split():

   372

            strippedline = line.strip()

   373

            attrs = dict(

   374

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

   375

   376

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

   377

   378

        self.ProgressEnd("inkscape")

   379

        return res

   380

   381

    def GetHMITree(self):

   382

        global hmi_tree_root

   383

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

   384

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

   385

        self.ProgressEnd("hmitree")

   386

        return res

   387

   388

    def GetTranslations(self, _context, msgs):

   389

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

   390

        messages = EtreeToMessages(msgs)

   391

   392

        if len(messages) == 0:

   393

            self.ProgressEnd("i18n")

   394

            return

   395

   396

        SaveCatalog(self._getPOTpath(), messages)

   397

   398

        translations = ReadTranslations(self.CTNPath())

   399

   400

        langs,translated_messages = MatchTranslations(translations, messages, 

   401

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

   402

   403

        ret = TranslationToEtree(langs,translated_messages)

   404

   405

        self.ProgressEnd("i18n")

   406

   407

        return ret

   408

   409

    def GetFontsFiles(self):

   410

        project_path = self.CTNPath()

   411

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

   412

        if os.path.isdir(fontdir):

   413

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

   414

        return []

   415

   416

    def GetFonts(self, _context):

   417

        css_parts = []

   418

   419

        for fontfile in self.GetFontsFiles():

   420

            if os.path.isfile(fontfile):

   421

                css_parts.append(GetCSSFontFaceFromFontFile(fontfile))

   422

   423

        return "".join(css_parts)

   424

   425

    times_msgs = {}

   426

    indent = 1

   427

    def ProgressStart(self, k, m):

   428

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

   429

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

   430

        self.indent = self.indent + 1

   431

   432

    def ProgressEnd(self, k):

   433

        t = time.time()

   434

        oldt, m = self.times_msgs[k]

   435

        self.indent = self.indent - 1

   436

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

   437

   438

    def CTNGenerate_C(self, buildpath, locations):

   439

   440

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

   441

        view_name = self.BaseParams.getName()

   442

   443

        svgfile = self._getSVGpath()

   444

   445

        res = ([], "", False)

   446

   447

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

   448

   449

        build_path = self._getBuildPath()

   450

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

   451

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

   452

   453

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

   454

   455

        if os.path.exists(svgfile):

   456

   457

            hasher = hashlib.md5()

   458

            hmi_tree_root._hash(hasher)

   459

            pofiles = GetPoFiles(self.CTNPath())

   460

            filestocheck = [svgfile] + \

   461

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

   462

                           self.GetFontsFiles()

   463

   464

            for filetocheck in filestocheck:

   465

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

   466

                    while True:

   467

                        buf = afile.read(65536)

   468

                        if len(buf) > 0:

   469

                            hasher.update(buf)

   470

                        else:

   471

                            break

   472

            digest = hasher.hexdigest()

   473

   474

            if os.path.exists(hash_path):

   475

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

   476

                    last_digest = digest_file.read()

   477

            else:

   478

                last_digest = None

   479

   480

            if digest != last_digest:

   481

   482

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

   483

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

   484

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

   485

                               ("GetTranslations", self.GetTranslations),

   486

                               ("GetFonts", self.GetFonts),

   487

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

   488