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 pprint, pformat

    14

    15

import wx

    16

    17

import util.paths as paths

    18

from POULibrary import POULibrary

    19

from docutil import open_svg, get_inkscape_path

    20

from lxml import etree

    21

    22

from util.ProcessLogger import ProcessLogger

    23

from runtime.typemapping import DebugTypesSize

    25

    26

HMI_TYPES_DESC = {

    27

    "HMI_CLASS":{},

    28

    "HMI_LABEL":{},

    29

    "HMI_STRING":{},

    30

    "HMI_INT":{},

    31

    "HMI_REAL":{}

    32

}

    33

    34

HMI_TYPES = HMI_TYPES_DESC.keys()

    35

    36

from XSLTransform import XSLTransform

    37

    38

ScriptDirectory = paths.AbsDir(__file__)

    39

    40

class HMITreeNode(object):

    41

    def __init__(self, path, name, nodetype, iectype = None, vartype = None):

    42

        self.path = path

    43

        self.name = name

    44

        self.nodetype = nodetype

    45

    46

        if iectype is not None:

    47

            self.iectype = iectype

    48

            self.vartype = vartype

    49

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

    50

            self.children = []

    51

    52

    def pprint(self, indent = 0):

    53

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

    54

        if hasattr(self, "children"): 

    55

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

    56

                              for child in self.children])

    57

            res += "\n"

    58

    59

        return res

    60

    61

    def place_node(self, node):

    62

        best_child = None

    63

        known_best_match = 0

    64

        for child in self.children : 

    65

            if child.path is not None:

    66

                in_common = 0

    67

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

    68

                    if child_path_item == node_path_item:

    69

                        in_common +=1

    70

                    else:

    71

                        break

    72

                if in_common > known_best_match:

    73

                    known_best_match = in_common

    74

                    best_child = child

    75

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

    76

            best_child.place_node(node)

    77

        else:

    78

            self.children.append(node)

    79

    80

    def etree(self):

    81

    82

        attribs = dict(name=self.name)

    83

        if self.path is not None:

    84

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

    85

    86

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

    87

    88

        if hasattr(self, "children"): 

    89

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

    90

                res.append(child_etree)

    91

    92

        return res

    93

    94

    def traverse(self):

    95

        yield self

    96

        if hasattr(self, "children"): 

    97

            for c in self.children:

    98

                for yoodl in c.traverse():

    99

                    yield yoodl

   100

   101

# module scope for HMITree root

   102

# so that CTN can use HMITree deduced in Library

   103

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

   104

#       systematicaly invoked before CTN's CTNGenerate_C

   105

   106

hmi_tree_root = None

   107

   108

class SVGHMILibrary(POULibrary):

   109

    def GetLibraryPath(self):

   110

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

   111

   112

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

   113

        global hmi_tree_root

   114

   115

        """

   116

        PLC Instance Tree:

   117

          prog0

   118

           +->v1 HMI_INT

   119

           +->v2 HMI_INT

   120

           +->fb0 (type mhoo)

   121

           |   +->va HMI_LABEL

   122

           |   +->v3 HMI_INT

   123

           |   +->v4 HMI_INT

   124

           |

   125

           +->fb1 (type mhoo)

   126

           |   +->va HMI_LABEL

   127

           |   +->v3 HMI_INT

   128

           |   +->v4 HMI_INT

   129

           |

   130

           +->fb2

   131

               +->v5 HMI_IN

   132

   133

        HMI tree:

   134

          hmi0

   135

           +->v1

   136

           +->v2

   137

           +->fb0_va

   138

           |   +-> v3

   139

           |   +-> v4

   140

           |

   141

           +->fb1_va

   142

           |   +-> v3

   143

           |   +-> v4

   144

           |

   145

           +->v5

   146

   147

        """

   148

   149

        # Filter known HMI types

   150

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

   151

   152

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

   153

   154

        # add special nodes 

   155

        map(lambda (n,t): hmi_tree_root.children.append(HMITreeNode(None,n,t)), [

   156

                ("plc_status", "HMI_PLC_STATUS"),

   157

                ("current_page", "HMI_CURRENT_PAGE")])

   158

   159

        # deduce HMI tree from PLC HMI_* instances

   160

        for v in hmi_types_instances:

   161

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

   162

            # ignores variables starting with _TMP_

   163

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

   164

                continue

   165

            new_node = HMITreeNode(path, path[-1], v["derived"], v["type"], v["vartype"])

   166

            hmi_tree_root.place_node(new_node)

   167

   168

        print(hmi_tree_root.pprint())

   169

   170

        variable_decl_array = []

   171

        extern_variables_declarations = []

   172

        buf_index = 0

   173

        for node in hmi_tree_root.traverse():

   174

            if hasattr(node, "iectype"):

   175

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

   176

                variable_decl_array += [

   177

                    "{&(" + ".".join(node.path) + "), " + node.iectype + {

   178

                        "EXT": "_P_ENUM",

   179

                        "IN":  "_P_ENUM",

   180

                        "MEM": "_O_ENUM",

   181

                        "OUT": "_O_ENUM",

   182

                        "VAR": "_ENUM"

   183

                    }[node.vartype] + ", " +

   184

                    str(buf_index) + ", 0}"]

   185

                buf_index += sz

   186

                if len(node.path) == 1:

   187

                    extern_variables_declarations += [

   188

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

   189

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

   190

                        + ".".join(node.path) + ";"]

   191

   192

        # TODO : filter only requiered external declarations

   193

        for v in varlist :

   194

            if v["C_path"].find('.') < 0 and v["vartype"] == "FB" :

   195

                extern_variables_declarations += [

   196

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

   197

   198

        # TODO check if programs need to be declared separately

   199

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

   200

        #                                     p for p in self._ProgramList]),

   201

   202

        # TODO generate C code to observe/access HMI tree variables

   203

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

   204

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   205

        svghmi_c_code = svghmi_c_file.read()

   206

        svghmi_c_file.close()

   207

        svghmi_c_code = svghmi_c_code % { 

   208

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

   209

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

   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

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

   220

   221

class SVGHMI(object):

   222

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

   223

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

   224

      <xsd:element name="SVGHMI">

   225

        <xsd:complexType>

   226

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

   227

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

   228

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

   229

        </xsd:complexType>

   230

      </xsd:element>

   231

    </xsd:schema>

   232

    """

   233

   234

    ConfNodeMethods = [

   235

        {

   236

            "bitmap":    "ImportSVG",

   237

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

   238

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

   239

            "method":   "_ImportSVG"

   240

        },

   241

        {

   242

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

   243

            "name":    _("Inkscape"),

   244

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

   245

            "method":   "_StartInkscape"

   246

        },

   247

    ]

   248

   249

    def _getSVGpath(self, project_path=None):

   250

        if project_path is None:

   251

            project_path = self.CTNPath()

   252

        # define name for SVG file containing gui layout

   253

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

   254

   255

   256

    def OnCTNSave(self, from_project_path=None):

   257

        if from_project_path is not None:

   258

            shutil.copyfile(self._getSVGpath(from_project_path),

   259

                            self._getSVGpath())

   260

        return True

   261

   262

    def GetSVGGeometry(self):

   263

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

   264

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

   265

   266

        # TODO : move following line to __init__

   267

        inkpath = get_inkscape_path()

   268

        svgpath = self._getSVGpath()

   269

        _status, result, _err_result = ProcessLogger(None,

   270

                                                     inkpath + " -S " + svgpath,

   271

                                                     no_stdout=True,

   272

                                                     no_stderr=True).spin()

   273

        res = []

   274

        for line in result.split():

   275

            strippedline = line.strip()

   276

            attrs = dict(

   277

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

   278

   279

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

   280

   281

        return res

   282

   283

    def GetHMITree(self):

   284

        global hmi_tree_root

   285

        res = [hmi_tree_root.etree()]

   286

        return res

   287

   288

    def CTNGenerate_C(self, buildpath, locations):

   289

        """

   290

        Return C code generated by iec2c compiler

   291

        when _generate_softPLC have been called

   292

        @param locations: ignored

   293

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

   294

        """

   295

   296

        svgfile = self._getSVGpath()

   297

        if os.path.exists(svgfile):

   298

   299

            # TODO : move to __init__

   300

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

   301

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

   302

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

   303

   304

   305

            # load svg as a DOM with Etree

   306

            svgdom = etree.parse(svgfile)

   307

   308

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

   309

            result = transform.transform(svgdom)

   310

   311

            # print(str(result))

   312

            # print(transform.xslt.error_log)

   313

   314

            # TODO

   315

            #   - Errors on HMI semantics

   316

            #   - ... maybe something to have a global view of what is declared in SVG.

   317

   318

        else:

   319

            # TODO : use default svg that expose the HMI tree as-is 

   320

            pass

   321

   322

   323

        res = ([], "", False)

   324

   325

        targetpath = os.path.join(self._getBuildPath(), "target.xhtml")

   326

        targetfile = open(targetpath, 'w')

   327

   328

        # TODO : DOM to string

   329

        targetfile.write("TODO")

   330

        targetfile.close()

   331

        res += (("target.js", open(targetpath, "rb")),)

   332

   333

        # TODO add C code to expose HMI tree variables to shared memory

   334

        # TODO generate a description of shared memory (xml or CSV) 

   335

        #      that can be loaded by svghmi QTWeb* app or svghmi server

   336

   337

   338

        return res

   339

   340

    def _ImportSVG(self):

   341

        dialog = wx.FileDialog(self.GetCTRoot().AppFrame, _("Choose a SVG file"), os.getcwd(), "",  _("SVG files (*.svg)|*.svg|All files|*.*"), wx.OPEN)

   342

        if dialog.ShowModal() == wx.ID_OK:

   343

            svgpath = dialog.GetPath()

   344

            if os.path.isfile(svgpath):

   345

                shutil.copy(svgpath, self._getSVGpath())

   346

            else:

   347

                self.GetCTRoot().logger.write_error(_("No such SVG file: %s\n") % svgpath)

   348

        dialog.Destroy()

   349

   350

    def _StartInkscape(self):

   351

        svgfile = self._getSVGpath()

   352

        open_inkscape = True

   353

        if not self.GetCTRoot().CheckProjectPathPerm():

   354

            dialog = wx.MessageDialog(self.GetCTRoot().AppFrame,

   355

                                      _("You don't have write permissions.\nOpen Inkscape anyway ?"),

   356

                                      _("Open Inkscape"),

   357

                                      wx.YES_NO | wx.ICON_QUESTION)

   358

            open_inkscape = dialog.ShowModal() == wx.ID_YES

   359

            dialog.Destroy()

   360

        if open_inkscape:

   361

            if not os.path.isfile(svgfile):

   362

                svgfile = None

   363

            open_svg(svgfile)