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

    58

        for child in self.children:

    59

            in_common = 0

    60

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

    61

                if child_path_item == node_path_item:

    62

                    in_common +=1

    63

                else:

    64

                    break

    65

            if in_common > known_best_match:

    66

                known_best_match = in_common

    67

                best_child = child

    68

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

    69

            best_child.place_node(node)

    70

        else:

    71

            self.children.append(node)

    72

    73

    74

class SVGHMILibrary(POULibrary):

    75

    def GetLibraryPath(self):

    76

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

    77

    78

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

    79

    80

        """

    81

        PLC Instance Tree:

    82

          prog0

    83

           +->v1 HMI_INT

    84

           +->v2 HMI_INT

    85

           +->fb0 (type mhoo)

    86

           |   +->va HMI_LABEL

    87

           |   +->v3 HMI_INT

    88

           |   +->v4 HMI_INT

    89

           |

    90

           +->fb1 (type mhoo)

    91

           |   +->va HMI_LABEL

    92

           |   +->v3 HMI_INT

    93

           |   +->v4 HMI_INT

    94

           |

    95

           +->fb2

    96

               +->v5 HMI_IN

    97

    98

        HMI tree:

    99

          hmi0

   100

           +->v1

   101

           +->v2

   102

           +->fb0_va

   103

           |   +-> v3

   104

           |   +-> v4

   105

           |

   106

           +->fb1_va

   107

           |   +-> v3

   108

           |   +-> v4

   109

           |

   110

           +->v5

   111

   112

        """

   113

   114

        # Filter known HMI types

   115

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

   116

   117

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

   118

   119

        # TODO add always available variables here ?

   120

        #    - plc status

   121

        #    - current page

   122

        #    - ...

   123

   124

        # deduce HMI tree from PLC HMI_* instances

   125

        for v in hmi_types_instances:

   126

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

   127

            # ignores variables starting with _TMP_

   128

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

   129

                continue

   130

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

   131

            hmi_tree_root.place_node(new_node)

   132

   133

        print(hmi_tree_root.pprint())

   134

   135

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

   136

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

   137

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   138

        svghmi_c_code = svghmi_c_file.read()

   139

        svghmi_c_file.close()

   140

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

   141

   142

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

   143

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   144

        gen_svghmi_c.write(svghmi_c_code)

   145

        gen_svghmi_c.close()

   146

   147

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

   148

   149

class SVGHMI(object):

   150

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

   151

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

   152

      <xsd:element name="SVGHMI">

   153

        <xsd:complexType>

   154

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

   155

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

   156

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

   157

        </xsd:complexType>

   158

      </xsd:element>

   159

    </xsd:schema>

   160

    """

   161

   162

    ConfNodeMethods = [

   163

        {

   164

            "bitmap":    "ImportSVG",

   165

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

   166

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

   167

            "method":   "_ImportSVG"

   168

        },

   169

        {

   170

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

   171

            "name":    _("Inkscape"),

   172

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

   173

            "method":   "_StartInkscape"

   174

        },

   175

    ]

   176

   177

    def _getSVGpath(self, project_path=None):

   178

        if project_path is None:

   179

            project_path = self.CTNPath()

   180

        # define name for SVG file containing gui layout

   181

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

   182

   183

   184

    def OnCTNSave(self, from_project_path=None):

   185

        if from_project_path is not None:

   186

            shutil.copyfile(self._getSVGpath(from_project_path),

   187

                            self._getSVGpath())

   188

        return True

   189

   190

    def GetSVGGeometry(self):

   191

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

   192

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

   193

   194

        # TODO : move following line to __init__

   195

        inkpath = get_inkscape_path()

   196

        svgpath = self._getSVGpath()

   197

        _status, result, _err_result = ProcessLogger(None,

   198

                                                     inkpath + " -S " + svgpath,

   199

                                                     no_stdout=True,

   200

                                                     no_stderr=True).spin()

   201

        res = []

   202

        for line in result.split():

   203

            strippedline = line.strip()

   204

            attrs = dict(

   205

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

   206

   207

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

   208

   209

        return res

   210

   211

    def CTNGenerate_C(self, buildpath, locations):

   212

        """

   213

        Return C code generated by iec2c compiler

   214

        when _generate_softPLC have been called

   215

        @param locations: ignored

   216

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

   217

        """

   218

   219

        # TODO fetch HMI tree from library

   220

   221

        svgfile = self._getSVGpath()

   222

        if os.path.exists(svgfile):

   223

   224

            # TODO : move to __init__

   225

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

   226

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

   227

   228

   229

            # load svg as a DOM with Etree

   230

            svgdom = etree.parse(svgfile)

   231

   232

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

   233

            result = transform.transform(svgdom)

   234

   235

            print(str(result))

   236

            print(transform.xslt.error_log)

   237

   238

            # TODO

   239

            #   - Errors on HMI semantics

   240

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

   241

   242

        else:

   243

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

   244

            pass

   245

   246

   247

        res = ([], "", False)

   248

   249

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

   250

        targetfile = open(targetpath, 'w')

   251

   252

        # TODO : DOM to string

   253

        targetfile.write("TODO")

   254

        targetfile.close()

   255

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

   256

   257

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

   258

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

   259

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

   260

   261

   262

        return res

   263

   264

    def _ImportSVG(self):

   265

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

   266

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

   267

            svgpath = dialog.GetPath()

   268

            if os.path.isfile(svgpath):

   269

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

   270

            else:

   271

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

   272

        dialog.Destroy()

   273

   274

    def _StartInkscape(self):

   275

        svgfile = self._getSVGpath()

   276

        open_inkscape = True

   277

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

   278

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

   279

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

   280

                                      _("Open Inkscape"),

   281

                                      wx.YES_NO | wx.ICON_QUESTION)

   282

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

   283

            dialog.Destroy()

   284

        if open_inkscape:

   285

            if not os.path.isfile(svgfile):

   286

                svgfile = None

   287

            open_svg(svgfile)