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

    24

    25

HMI_TYPES_DESC = {

    26

    "HMI_CLASS":{},

    27

    "HMI_LABEL":{},

    28

    "HMI_STRING":{},

    29

    "HMI_INT":{},

    30

    "HMI_REAL":{}

    31

}

    32

    33

HMI_TYPES = HMI_TYPES_DESC.keys()

    34

    35

from XSLTransform import XSLTransform

    36

    37

ScriptDirectory = paths.AbsDir(__file__)

    38

    39

class HMITreeNode(object):

    40

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

    41

        self.path = path

    42

        self.name = name

    43

        self.nodetype = nodetype

    44

    45

        if iectype is not None:

    46

            self.iectype = iectype

    47

            self.vartype = vartype

    48

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

    49

            self.children = []

    50

    51

    def pprint(self, indent = 0):

    52

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

    53

        if hasattr(self, "children"): 

    54

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

    55

                              for child in self.children])

    56

            res += "\n"

    57

    58

        return res

    59

    60

    def place_node(self, node):

    61

        best_child = None

    62

        known_best_match = 0

    63

        for child in self.children : 

    64

            if child.path is not None:

    65

                in_common = 0

    66

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

    67

                    if child_path_item == node_path_item:

    68

                        in_common +=1

    69

                    else:

    70

                        break

    71

                if in_common > known_best_match:

    72

                    known_best_match = in_common

    73

                    best_child = child

    74

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

    75

            best_child.place_node(node)

    76

        else:

    77

            self.children.append(node)

    78

    79

    def etree(self):

    80

    81

        attribs = dict(name=self.name)

    82

        if self.path is not None:

    83

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

    84

    85

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

    86

    87

        if hasattr(self, "children"): 

    88

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

    89

                res.append(child_etree)

    90

    91

        return res

    92

    93

    def traverse(self):

    94

        yield self

    95

        if hasattr(self, "children"): 

    96

            for c in self.children:

    97

                for yoodl in c.traverse():

    98

                    yield yoodl

    99

   100

# module scope for HMITree root

   101

# so that CTN can use HMITree deduced in Library

   102

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

   103

#       systematicaly invoked before CTN's CTNGenerate_C

   104

   105

hmi_tree_root = None

   106

   107

class SVGHMILibrary(POULibrary):

   108

    def GetLibraryPath(self):

   109

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

   110

   111

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

   112

        global hmi_tree_root

   113

   114

        """

   115

        PLC Instance Tree:

   116

          prog0

   117

           +->v1 HMI_INT

   118

           +->v2 HMI_INT

   119

           +->fb0 (type mhoo)

   120

           |   +->va HMI_LABEL

   121

           |   +->v3 HMI_INT

   122

           |   +->v4 HMI_INT

   123

           |

   124

           +->fb1 (type mhoo)

   125

           |   +->va HMI_LABEL

   126

           |   +->v3 HMI_INT

   127

           |   +->v4 HMI_INT

   128

           |

   129

           +->fb2

   130

               +->v5 HMI_IN

   131

   132

        HMI tree:

   133

          hmi0

   134

           +->v1

   135

           +->v2

   136

           +->fb0_va

   137

           |   +-> v3

   138

           |   +-> v4

   139

           |

   140

           +->fb1_va

   141

           |   +-> v3

   142

           |   +-> v4

   143

           |

   144

           +->v5

   145

   146

        """

   147

   148

        # Filter known HMI types

   149

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

   150

   151

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

   152

   153

        # add special nodes 

   154

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

   155

                ("plc_status", "HMI_PLC_STATUS"),

   156

                ("current_page", "HMI_CURRENT_PAGE")])

   157

   158

        # deduce HMI tree from PLC HMI_* instances

   159

        for v in hmi_types_instances:

   160

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

   161

            # ignores variables starting with _TMP_

   162

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

   163

                continue

   164

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

   165

            hmi_tree_root.place_node(new_node)

   166

   167

        print(hmi_tree_root.pprint())

   168

   169

        variable_decl_array = []

   170

        extern_variables_declarations = []

   172

        for node in hmi_tree_root.traverse():

   173

            if hasattr(node, "iectype"):

   174

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

   175

                variable_decl_array += [

   176

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

   177

                        "EXT": "_P_ENUM",

   178

                        "IN":  "_P_ENUM",

   179

                        "MEM": "_O_ENUM",

   180

                        "OUT": "_O_ENUM",

   181

                        "VAR": "_ENUM"

   185

                if len(node.path) == 1:

   186

                    extern_variables_declarations += [

   187

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

   188

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

   189

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

   190

   191

        # TODO : filter only requiered external declarations

   192

        for v in varlist :

   193

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

   194

                extern_variables_declarations += [

   195

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

   196

   197

        # TODO check if programs need to be declared separately

   198

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

   199

        #                                     p for p in self._ProgramList]),

   200

   201

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

   202

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

   203

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   204

        svghmi_c_code = svghmi_c_file.read()

   205

        svghmi_c_file.close()

   206

        svghmi_c_code = svghmi_c_code % { 

   207

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

   208

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

   210

            }

   211

   212

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

   213

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   214

        gen_svghmi_c.write(svghmi_c_code)

   215

        gen_svghmi_c.close()

   216

   217

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

   218

   219

class SVGHMI(object):

   220

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

   221

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

   222

      <xsd:element name="SVGHMI">

   223

        <xsd:complexType>

   224

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

   225

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

   226

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

   227

        </xsd:complexType>

   228

      </xsd:element>

   229

    </xsd:schema>

   230

    """

   231

   232

    ConfNodeMethods = [

   233

        {

   234

            "bitmap":    "ImportSVG",

   235

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

   236

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

   237

            "method":   "_ImportSVG"

   238

        },

   239

        {

   240

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

   241

            "name":    _("Inkscape"),

   242

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

   243

            "method":   "_StartInkscape"

   244

        },

   245

    ]

   246

   247

    def _getSVGpath(self, project_path=None):

   248

        if project_path is None:

   249

            project_path = self.CTNPath()

   250

        # define name for SVG file containing gui layout

   251

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

   252

   253

   254

    def OnCTNSave(self, from_project_path=None):

   255

        if from_project_path is not None:

   256

            shutil.copyfile(self._getSVGpath(from_project_path),

   257

                            self._getSVGpath())

   258

        return True

   259

   260

    def GetSVGGeometry(self):

   261

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

   262

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

   263

   264

        # TODO : move following line to __init__

   265

        inkpath = get_inkscape_path()

   266

        svgpath = self._getSVGpath()

   267

        _status, result, _err_result = ProcessLogger(None,

   268

                                                     inkpath + " -S " + svgpath,

   269

                                                     no_stdout=True,

   270

                                                     no_stderr=True).spin()

   271

        res = []

   272

        for line in result.split():

   273

            strippedline = line.strip()

   274

            attrs = dict(

   275

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

   276

   277

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

   278

   279

        return res

   280

   281

    def GetHMITree(self):

   282

        global hmi_tree_root

   283

        res = [hmi_tree_root.etree()]

   284

        return res

   285

   286

    def CTNGenerate_C(self, buildpath, locations):

   287

        """

   288

        Return C code generated by iec2c compiler

   289

        when _generate_softPLC have been called

   290

        @param locations: ignored

   291

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

   292

        """

   293

   294

        svgfile = self._getSVGpath()

   295

        if os.path.exists(svgfile):

   296

   297

            # TODO : move to __init__

   298

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

   299

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

   300

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

   301

   302

   303

            # load svg as a DOM with Etree

   304

            svgdom = etree.parse(svgfile)

   305

   306

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

   307

            result = transform.transform(svgdom)

   308

   309

            # print(str(result))

   310

            # print(transform.xslt.error_log)

   311

   312

            # TODO

   313

            #   - Errors on HMI semantics

   314

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

   315

   316

        else:

   317

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

   318

            pass

   319

   320

   321

        res = ([], "", False)

   322

   323

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

   324

        targetfile = open(targetpath, 'w')

   325

   326

        # TODO : DOM to string

   327

        targetfile.write("TODO")

   328

        targetfile.close()

   329

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

   330

   331

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

   332

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

   333

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

   334

   335

   336

        return res

   337

   338

    def _ImportSVG(self):

   339

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

   340

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

   341

            svgpath = dialog.GetPath()

   342

            if os.path.isfile(svgpath):

   343

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

   344

            else:

   345

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

   346

        dialog.Destroy()

   347

   348

    def _StartInkscape(self):

   349

        svgfile = self._getSVGpath()

   350

        open_inkscape = True

   351

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

   352

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

   353

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

   354

                                      _("Open Inkscape"),

   355

                                      wx.YES_NO | wx.ICON_QUESTION)

   356

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

   357

            dialog.Destroy()

   358

        if open_inkscape:

   359

            if not os.path.isfile(svgfile):

   360

                svgfile = None

   361

            open_svg(svgfile)