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

import targets

    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

   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),

   210

            "buffer_size": buf_index,

   211

            "var_access_code": targets.GetCode("var_access.c"),

   213

            }

   214

   215

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

   216

        gen_svghmi_c = open(gen_svghmi_c_path, 'w')

   217

        gen_svghmi_c.write(svghmi_c_code)

   218

        gen_svghmi_c.close()

   219

   232

   233

class SVGHMI(object):

   235

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

   236

      <xsd:element name="SVGHMI">

   237

        <xsd:complexType>

   238

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

   239

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

   240

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

   241

        </xsd:complexType>

   242

      </xsd:element>

   243

    </xsd:schema>

   244

    """

   245

   246

    ConfNodeMethods = [

   247

        {

   248

            "bitmap":    "ImportSVG",

   249

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

   250

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

   251

            "method":   "_ImportSVG"

   252

        },

   253

        {

   254

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

   255

            "name":    _("Inkscape"),

   256

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

   257

            "method":   "_StartInkscape"

   258

        },

   263

    ]

   264

   265

    def _getSVGpath(self, project_path=None):

   266

        if project_path is None:

   267

            project_path = self.CTNPath()

   268

        # define name for SVG file containing gui layout

   269

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

   270

   271

   272

    def OnCTNSave(self, from_project_path=None):

   273

        if from_project_path is not None:

   274

            shutil.copyfile(self._getSVGpath(from_project_path),

   275

                            self._getSVGpath())

   276

        return True

   277

   278

    def GetSVGGeometry(self):

   279

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

   280

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

   281

   282

        # TODO : move following line to __init__

   283

        inkpath = get_inkscape_path()

   284

        svgpath = self._getSVGpath()

   285

        _status, result, _err_result = ProcessLogger(None,

   286

                                                     inkpath + " -S " + svgpath,

   287

                                                     no_stdout=True,

   288

                                                     no_stderr=True).spin()

   289

        res = []

   290

        for line in result.split():

   291

            strippedline = line.strip()

   292

            attrs = dict(

   293

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

   294

   295

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

   296

   297

        return res

   298

   299

    def GetHMITree(self):

   300

        global hmi_tree_root

   301

        res = [hmi_tree_root.etree()]

   302

        return res

   303

   304

    def CTNGenerate_C(self, buildpath, locations):

   305

        """

   306

        Return C code generated by iec2c compiler

   307

        when _generate_softPLC have been called

   308

        @param locations: ignored

   309

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

   310

        """

   311

   315

        svgfile = self._getSVGpath()

   324

        if os.path.exists(svgfile):

   325

   326

            # TODO : move to __init__

   327

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

   328

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

   329

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

   330

   331

   332

            # load svg as a DOM with Etree

   333

            svgdom = etree.parse(svgfile)

   334

   335

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

   336

            result = transform.transform(svgdom)

   337

   339

            # print(str(result))

   340

            # print(transform.xslt.error_log)

   341

   342

            # TODO

   343

            #   - Errors on HMI semantics

   344

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

   345

   346

        else:

   347

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

   371

   372

        return res

   373

   374

    def _ImportSVG(self):

   375

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

   376

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

   377

            svgpath = dialog.GetPath()

   378

            if os.path.isfile(svgpath):

   379

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

   380

            else:

   381

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

   382

        dialog.Destroy()

   383

   384

    def _StartInkscape(self):

   385

        svgfile = self._getSVGpath()

   386

        open_inkscape = True

   387

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

   388

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

   389

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

   390

                                      _("Open Inkscape"),

   391

                                      wx.YES_NO | wx.ICON_QUESTION)

   392

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

   393

            dialog.Destroy()

   394

        if open_inkscape:

   395

            if not os.path.isfile(svgfile):

   396

                svgfile = None

   397

            open_svg(svgfile)