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

    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

            if child.path is not None:

    60

                in_common = 0

    61

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

    62

                    if child_path_item == node_path_item:

    63

                        in_common +=1

    64

                    else:

    65

                        break

    66

                if in_common > known_best_match:

    67

                    known_best_match = in_common

    68

                    best_child = child

    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

    94

    95

class SVGHMILibrary(POULibrary):

    96

    def GetLibraryPath(self):

    97

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

    98

    99

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

   101

   102

        """

   103

        PLC Instance Tree:

   104

          prog0

   105

           +->v1 HMI_INT

   106

           +->v2 HMI_INT

   107

           +->fb0 (type mhoo)

   108

           |   +->va HMI_LABEL

   109

           |   +->v3 HMI_INT

   110

           |   +->v4 HMI_INT

   111

           |

   112

           +->fb1 (type mhoo)

   113

           |   +->va HMI_LABEL

   114

           |   +->v3 HMI_INT

   115

           |   +->v4 HMI_INT

   116

           |

   117

           +->fb2

   118

               +->v5 HMI_IN

   119

   120

        HMI tree:

   121

          hmi0

   122

           +->v1

   123

           +->v2

   124

           +->fb0_va

   125

           |   +-> v3

   126

           |   +-> v4

   127

           |

   128

           +->fb1_va

   129

           |   +-> v3

   130

           |   +-> v4

   131

           |

   132

           +->v5

   133

   134

        """

   135

   136

        # Filter known HMI types

   137

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

   138

   139

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

   140

   141

        # add special nodes 

   142

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

   143

                ("plc_status", "HMI_PLC_STATUS"),

   144

                ("current_page", "HMI_CURRENT_PAGE")])

   145

   146

        # deduce HMI tree from PLC HMI_* instances

   147

        for v in hmi_types_instances:

   148

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

   149

            # ignores variables starting with _TMP_

   150

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

   151

                continue

   152

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

   153

            hmi_tree_root.place_node(new_node)

   154

   155

        print(hmi_tree_root.pprint())

   156

   157

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

   158

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

   159

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   160

        svghmi_c_code = svghmi_c_file.read()

   161

        svghmi_c_file.close()

   162

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

   163

   164

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

   165

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   166

        gen_svghmi_c.write(svghmi_c_code)

   167

        gen_svghmi_c.close()

   168

   169

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

   170

   171

class SVGHMI(object):

   172

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

   173

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

   174

      <xsd:element name="SVGHMI">

   175

        <xsd:complexType>

   176

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

   177

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

   178

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

   179

        </xsd:complexType>

   180

      </xsd:element>

   181

    </xsd:schema>

   182

    """

   183

   184

    ConfNodeMethods = [

   185

        {

   186

            "bitmap":    "ImportSVG",

   187

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

   188

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

   189

            "method":   "_ImportSVG"

   190

        },

   191

        {

   192

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

   193

            "name":    _("Inkscape"),

   194

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

   195

            "method":   "_StartInkscape"

   196

        },

   197

    ]

   198

   199

    def _getSVGpath(self, project_path=None):

   200

        if project_path is None:

   201

            project_path = self.CTNPath()

   202

        # define name for SVG file containing gui layout

   203

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

   204

   205

   206

    def OnCTNSave(self, from_project_path=None):

   207

        if from_project_path is not None:

   208

            shutil.copyfile(self._getSVGpath(from_project_path),

   209

                            self._getSVGpath())

   210

        return True

   211

   212

    def GetSVGGeometry(self):

   213

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

   214

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

   215

   216

        # TODO : move following line to __init__

   217

        inkpath = get_inkscape_path()

   218

        svgpath = self._getSVGpath()

   219

        _status, result, _err_result = ProcessLogger(None,

   220

                                                     inkpath + " -S " + svgpath,

   221

                                                     no_stdout=True,

   222

                                                     no_stderr=True).spin()

   223

        res = []

   224

        for line in result.split():

   225

            strippedline = line.strip()

   226

            attrs = dict(

   227

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

   228

   229

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

   230

   231

        return res

   232

   238

    def CTNGenerate_C(self, buildpath, locations):

   239

        """

   240

        Return C code generated by iec2c compiler

   241

        when _generate_softPLC have been called

   242

        @param locations: ignored

   243

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

   244

        """

   245

   246

        # TODO fetch HMI tree from library

   247

   248

        svgfile = self._getSVGpath()

   249

        if os.path.exists(svgfile):

   250

   251

            # TODO : move to __init__

   252

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

   255

   256

   257

            # load svg as a DOM with Etree

   258

            svgdom = etree.parse(svgfile)

   259

   260

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

   261

            result = transform.transform(svgdom)

   262

   263

            print(str(result))

   264

            print(transform.xslt.error_log)

   265

   266

            # TODO

   267

            #   - Errors on HMI semantics

   268

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

   269

   270

        else:

   271

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

   272

            pass

   273

   274

   275

        res = ([], "", False)

   276

   277

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

   278

        targetfile = open(targetpath, 'w')

   279

   280

        # TODO : DOM to string

   281

        targetfile.write("TODO")

   282

        targetfile.close()

   283

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

   284

   285

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

   286

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

   287

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

   288

   289

   290

        return res

   291

   292

    def _ImportSVG(self):

   293

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

   294

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

   295

            svgpath = dialog.GetPath()

   296

            if os.path.isfile(svgpath):

   297

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

   298

            else:

   299

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

   300

        dialog.Destroy()

   301

   302

    def _StartInkscape(self):

   303

        svgfile = self._getSVGpath()

   304

        open_inkscape = True

   305

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

   306

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

   307

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

   308

                                      _("Open Inkscape"),

   309

                                      wx.YES_NO | wx.ICON_QUESTION)

   310

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

   311

            dialog.Destroy()

   312

        if open_inkscape:

   313

            if not os.path.isfile(svgfile):

   314

                svgfile = None

   315

            open_svg(svgfile)