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

    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

    24

HMI_TYPES_DESC = {

    25

    "HMI_CLASS":{},

    26

    "HMI_LABEL":{},

    27

    "HMI_STRING":{},

    28

    "HMI_INT":{},

    29

    "HMI_REAL":{}

    30

}

    31

    32

HMI_TYPES = HMI_TYPES_DESC.keys()

    33

    34

from XSLTransform import XSLTransform

    35

    36

ScriptDirectory = paths.AbsDir(__file__)

    37

    38

class HMITreeNode(object):

    39

    def __init__(self, path, name, nodetype):

    40

        self.path = path

    41

        self.name = name

    42

        self.nodetype = nodetype

    43

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

    44

            self.children = []

    45

    46

    def pprint(self, indent = 0):

    47

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

    48

        if hasattr(self, "children"): 

    49

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

    50

                              for child in self.children])

    51

            res += "\n"

    52

    53

        return res

    54

    55

    def place_node(self, node):

    56

        best_child = None

    57

        known_best_match = 0

    69

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

    70

            best_child.place_node(node)

    71

        else:

    72

            self.children.append(node)

    73

    74

    75

class SVGHMILibrary(POULibrary):

    76

    def GetLibraryPath(self):

    77

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

    78

    79

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

    80

    81

        """

    82

        PLC Instance Tree:

    83

          prog0

    84

           +->v1 HMI_INT

    85

           +->v2 HMI_INT

    86

           +->fb0 (type mhoo)

    87

           |   +->va HMI_LABEL

    88

           |   +->v3 HMI_INT

    89

           |   +->v4 HMI_INT

    90

           |

    91

           +->fb1 (type mhoo)

    92

           |   +->va HMI_LABEL

    93

           |   +->v3 HMI_INT

    94

           |   +->v4 HMI_INT

    95

           |

    96

           +->fb2

    97

               +->v5 HMI_IN

    98

    99

        HMI tree:

   100

          hmi0

   101

           +->v1

   102

           +->v2

   103

           +->fb0_va

   104

           |   +-> v3

   105

           |   +-> v4

   106

           |

   107

           +->fb1_va

   108

           |   +-> v3

   109

           |   +-> v4

   110

           |

   111

           +->v5

   112

   113

        """

   114

   115

        # Filter known HMI types

   116

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

   117

   118

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

   119

   124

   125

        # deduce HMI tree from PLC HMI_* instances

   126

        for v in hmi_types_instances:

   127

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

   128

            # ignores variables starting with _TMP_

   129

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

   130

                continue

   131

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

   132

            hmi_tree_root.place_node(new_node)

   133

   134

        print(hmi_tree_root.pprint())

   135

   136

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

   137

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

   138

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   139

        svghmi_c_code = svghmi_c_file.read()

   140

        svghmi_c_file.close()

   141

        svghmi_c_code = svghmi_c_code % { "hmi_tree": "TODO !!!"}

   142

   143

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

   144

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   145

        gen_svghmi_c.write(svghmi_c_code)

   146

        gen_svghmi_c.close()

   147

   148

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

   149

   150

class SVGHMI(object):

   151

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

   152

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

   153

      <xsd:element name="SVGHMI">

   154

        <xsd:complexType>

   155

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

   156

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

   157

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

   158

        </xsd:complexType>

   159

      </xsd:element>

   160

    </xsd:schema>

   161

    """

   162

   163

    ConfNodeMethods = [

   164

        {

   165

            "bitmap":    "ImportSVG",

   166

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

   167

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

   168

            "method":   "_ImportSVG"

   169

        },

   170

        {

   171

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

   172

            "name":    _("Inkscape"),

   173

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

   174

            "method":   "_StartInkscape"

   175

        },

   176

    ]

   177

   178

    def _getSVGpath(self, project_path=None):

   179

        if project_path is None:

   180

            project_path = self.CTNPath()

   181

        # define name for SVG file containing gui layout

   182

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

   183

   184

   185

    def OnCTNSave(self, from_project_path=None):

   186

        if from_project_path is not None:

   187

            shutil.copyfile(self._getSVGpath(from_project_path),

   188

                            self._getSVGpath())

   189

        return True

   190

   191

    def GetSVGGeometry(self):

   192

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

   193

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

   194

   195

        # TODO : move following line to __init__

   196

        inkpath = get_inkscape_path()

   197

        svgpath = self._getSVGpath()

   198

        _status, result, _err_result = ProcessLogger(None,

   199

                                                     inkpath + " -S " + svgpath,

   200

                                                     no_stdout=True,

   201

                                                     no_stderr=True).spin()

   202

        res = []

   203

        for line in result.split():

   204

            strippedline = line.strip()

   205

            attrs = dict(

   206

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

   207

   208

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

   209

   210

        return res

   211

   212

    def CTNGenerate_C(self, buildpath, locations):

   213

        """

   214

        Return C code generated by iec2c compiler

   215

        when _generate_softPLC have been called

   216

        @param locations: ignored

   217

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

   218

        """

   219

   220

        # TODO fetch HMI tree from library

   221

   222

        svgfile = self._getSVGpath()

   223

        if os.path.exists(svgfile):

   224

   225

            # TODO : move to __init__

   226

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

   227

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

   228

   229

   230

            # load svg as a DOM with Etree

   231

            svgdom = etree.parse(svgfile)

   232

   233

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

   234

            result = transform.transform(svgdom)

   235

   236

            print(str(result))

   237

            print(transform.xslt.error_log)

   238

   239

            # TODO

   240

            #   - Errors on HMI semantics

   241

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

   242

   243

        else:

   244

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

   245

            pass

   246

   247

   248

        res = ([], "", False)

   249

   250

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

   251

        targetfile = open(targetpath, 'w')

   252

   253

        # TODO : DOM to string

   254

        targetfile.write("TODO")

   255

        targetfile.close()

   256

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

   257

   258

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

   259

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

   260

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

   261

   262

   263

        return res

   264

   265

    def _ImportSVG(self):

   266

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

   267

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

   268

            svgpath = dialog.GetPath()

   269

            if os.path.isfile(svgpath):

   270

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

   271

            else:

   272

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

   273

        dialog.Destroy()

   274

   275

    def _StartInkscape(self):

   276

        svgfile = self._getSVGpath()

   277

        open_inkscape = True

   278

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

   279

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

   280

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

   281

                                      _("Open Inkscape"),

   282

                                      wx.YES_NO | wx.ICON_QUESTION)

   283

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

   284

            dialog.Destroy()

   285

        if open_inkscape:

   286

            if not os.path.isfile(svgfile):

   287

                svgfile = None

   288

            open_svg(svgfile)