1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz

     6

#

     7

# See COPYING file for copyrights details.

     8

     9

from __future__ import absolute_import

    10

import os

    11

import shutil

    12

import hashlib

    13

import weakref

    14

import shlex

    15

import time

    16

    17

import wx

    18

    19

from lxml import etree

    20

from lxml.etree import XSLTApplyError

    21

    22

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    23

import util.paths as paths

    24

from POULibrary import POULibrary

    25

from docutil import open_svg, get_inkscape_path

    26

    27

from util.ProcessLogger import ProcessLogger

    28

from runtime.typemapping import DebugTypesSize

    29

import targets

    30

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    31

from XSLTransform import XSLTransform

    32

from svghmi.i18n import EtreeToMessages, SaveCatalog, ReadTranslations, MatchTranslations, TranslationToEtree, open_pofile

    34

    35

    36

ScriptDirectory = paths.AbsDir(__file__)

    37

    38

    39

# module scope for HMITree root

    40

# so that CTN can use HMITree deduced in Library

    41

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

    42

#       systematicaly invoked before CTN's CTNGenerate_C

    43

    44

hmi_tree_root = None

    45

    46

on_hmitree_update = None

    47

    48

class SVGHMILibrary(POULibrary):

    49

    def GetLibraryPath(self):

    50

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

    51

    52

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

    53

        global hmi_tree_root, on_hmitree_update

    54

    55

        """

    56

        PLC Instance Tree:

    57

          prog0

    58

           +->v1 HMI_INT

    59

           +->v2 HMI_INT

    60

           +->fb0 (type mhoo)

    61

           |   +->va HMI_NODE

    62

           |   +->v3 HMI_INT

    63

           |   +->v4 HMI_INT

    64

           |

    65

           +->fb1 (type mhoo)

    66

           |   +->va HMI_NODE

    67

           |   +->v3 HMI_INT

    68

           |   +->v4 HMI_INT

    69

           |

    70

           +->fb2

    71

               +->v5 HMI_IN

    72

    73

        HMI tree:

    74

          hmi0

    75

           +->v1

    76

           +->v2

    77

           +->fb0 class:va

    78

           |   +-> v3

    79

           |   +-> v4

    80

           |

    81

           +->fb1 class:va

    82

           |   +-> v3

    83

           |   +-> v4

    84

           |

    85

           +->v5

    86

    87

        """

    88

    89

        # Filter known HMI types

    90

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

    91

    92

        hmi_tree_root = None

    93

    94

        # take first HMI_NODE (placed as special node), make it root

    95

        for i,v in enumerate(hmi_types_instances):

    96

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

    97

            derived = v["derived"]

    98

            if derived == "HMI_NODE":

    99

                hmi_tree_root = HMITreeNode(path, "", derived, v["type"], v["vartype"], v["C_path"])

   100

                hmi_types_instances.pop(i)

   101

                break

   102

   103

        if hmi_tree_root is None:

   104

            self.FatalError("SVGHMI : Library is selected but not used. Please either deselect it in project config or add a SVGHMI node to project.")

   105

   106

        # deduce HMI tree from PLC HMI_* instances

   107

        for v in hmi_types_instances:

   108

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

   109

            # ignores variables starting with _TMP_

   110

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

   111

                continue

   112

            derived = v["derived"]

   113

            kwargs={}

   114

            if derived == "HMI_NODE":

   115

                # TODO : make problem if HMI_NODE used in CONFIG or RESOURCE

   116

                name = path[-2]

   117

                kwargs['hmiclass'] = path[-1]

   118

            else:

   119

                name = path[-1]

   120

            new_node = HMITreeNode(path, name, derived, v["type"], v["vartype"], v["C_path"], **kwargs)

   121

            placement_result = hmi_tree_root.place_node(new_node)

   122

            if placement_result is not None:

   123

                cause, problematic_node = placement_result

   124

                if cause == "Non_Unique":

   125

                    message = _("HMI tree nodes paths are not unique.\nConflicting variable: {} {}").format(

   126

                        ".".join(problematic_node.path),

   127

                        ".".join(new_node.path))

   128

   129

                    last_FB = None 

   130

                    for v in varlist:

   131

                        if v["vartype"] == "FB":

   132

                            last_FB = v 

   133

                        if v["C_path"] == problematic_node:

   134

                            break

   135

                    if last_FB is not None:

   136

                        failing_parent = last_FB["type"]

   137

                        message += "\n"

   138

                        message += _("Solution: Add HMI_NODE at beginning of {}").format(failing_parent)

   139

   140

                elif cause in ["Late_HMI_NODE", "Duplicate_HMI_NODE"]:

   141

                    cause, problematic_node = placement_result

   142

                    message = _("There must be only one occurrence of HMI_NODE before any HMI_* variable in POU.\nConflicting variable: {} {}").format(

   143

                        ".".join(problematic_node.path),

   144

                        ".".join(new_node.path))

   145

   146

                self.FatalError("SVGHMI : " + message)

   147

   148

        if on_hmitree_update is not None:

   149

            on_hmitree_update()

   150

   151

        variable_decl_array = []

   152

        extern_variables_declarations = []

   153

        buf_index = 0

   154

        item_count = 0

   155

        found_heartbeat = False

   156

   157

        hearbeat_IEC_path = ['CONFIG', 'HEARTBEAT']

   158

   159

        for node in hmi_tree_root.traverse():

   160

            if not found_heartbeat and node.path == hearbeat_IEC_path:

   161

                hmi_tree_hearbeat_index = item_count

   162

                found_heartbeat = True

   163

                extern_variables_declarations += [

   164

                    "#define heartbeat_index "+str(hmi_tree_hearbeat_index)

   165

                ]

   166

            if hasattr(node, "iectype"):

   167

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

   168

                variable_decl_array += [

   169

                    "{&(" + node.cpath + "), " + node.iectype + {

   170

                        "EXT": "_P_ENUM",

   171

                        "IN":  "_P_ENUM",

   172

                        "MEM": "_O_ENUM",

   173

                        "OUT": "_O_ENUM",

   174

                        "VAR": "_ENUM"

   175

                    }[node.vartype] + ", " +

   176

                    str(buf_index) + ", 0, }"]

   177

                buf_index += sz

   178

                item_count += 1

   179

                if len(node.path) == 1:

   180

                    extern_variables_declarations += [

   181

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

   182

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

   183

                        + node.cpath + ";"]

   184

   185

        assert(found_heartbeat)

   186

   187

        # TODO : filter only requiered external declarations

   188

        for v in varlist:

   189

            if v["C_path"].find('.') < 0:

   190

                extern_variables_declarations += [

   191

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

   192

   193

        # TODO check if programs need to be declared separately

   194

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

   195

        #                                     p for p in self._ProgramList]),

   196

   197

        # C code to observe/access HMI tree variables

   198

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

   199

        svghmi_c_file = open(svghmi_c_filepath, 'r')

   200

        svghmi_c_code = svghmi_c_file.read()

   201

        svghmi_c_file.close()

   202

        svghmi_c_code = svghmi_c_code % {

   203

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

   204

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

   205

            "buffer_size": buf_index,

   206

            "item_count": item_count,

   207

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

   208

            "PLC_ticktime": self.GetCTR().GetTicktime(),

   209

            "hmi_hash_ints": ",".join(map(str,hmi_tree_root.hash()))

   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

        # Python based WebSocket HMITree Server

   218

        svghmiserverfile = open(paths.AbsNeighbourFile(__file__, "svghmi_server.py"), 'r')

   219

        svghmiservercode = svghmiserverfile.read()

   220

        svghmiserverfile.close()

   221

   222

        runtimefile_path = os.path.join(buildpath, "runtime_00_svghmi.py")

   223

        runtimefile = open(runtimefile_path, 'w')

   224

        runtimefile.write(svghmiservercode)

   225

        runtimefile.close()

   226

   227

        # Backup HMI Tree in XML form so that it can be loaded without building

   228

        hmitree_backup_path = os.path.join(buildpath, "hmitree.xml")

   229

        hmitree_backup_file = open(hmitree_backup_path, 'wb')

   230

        hmitree_backup_file.write(etree.tostring(hmi_tree_root.etree()))

   231

        hmitree_backup_file.close()

   232

   233

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

   234

                ("runtime_00_svghmi.py", open(runtimefile_path, "rb")))

   235

                #         ^

   236

                # note the double zero after "runtime_", 

   237

                # to ensure placement before other CTN generated code in execution order

   238

   239

   240

def SVGHMIEditorUpdater(ref):

   241

    def SVGHMIEditorUpdate():

   242

        o = ref()

   243

        if o is not None:

   244

            wx.CallAfter(o.MakeTree)

   245

    return SVGHMIEditorUpdate

   246

   247

class HMITreeSelector(wx.TreeCtrl):

   248

    def __init__(self, parent):

   249

        global on_hmitree_update

   250

        wx.TreeCtrl.__init__(self, parent, style=(

   251

            wx.TR_MULTIPLE |

   252

            wx.TR_HAS_BUTTONS |

   253

            wx.SUNKEN_BORDER |

   254

            wx.TR_LINES_AT_ROOT))

   255

   256

        on_hmitree_update = SVGHMIEditorUpdater(weakref.ref(self))

   257

        self.MakeTree()

   258

   259

    def _recurseTree(self, current_hmitree_root, current_tc_root):

   260

        for c in current_hmitree_root.children:

   261

            if hasattr(c, "children"):

   262

                display_name = ('{} (class={})'.format(c.name, c.hmiclass)) \

   263

                               if c.hmiclass is not None else c.name

   264

                tc_child = self.AppendItem(current_tc_root, display_name)

   265

                self.SetPyData(tc_child, None) # TODO

   266

   267

                self._recurseTree(c,tc_child)

   268

            else:

   269

                display_name = '{} {}'.format(c.nodetype[4:], c.name)

   270

                tc_child = self.AppendItem(current_tc_root, display_name)

   271

                self.SetPyData(tc_child, None) # TODO

   272

   273

    def MakeTree(self):

   274

        global hmi_tree_root

   275

   276

        self.Freeze()

   277

   278

        self.root = None

   279

        self.DeleteAllItems()

   280

   281

        root_display_name = _("Please build to see HMI Tree") \

   282

            if hmi_tree_root is None else "HMI"

   283

        self.root = self.AddRoot(root_display_name)

   284

        self.SetPyData(self.root, None)

   285

   286

        if hmi_tree_root is not None:

   287

            self._recurseTree(hmi_tree_root, self.root)

   288

            self.Expand(self.root)

   289

   290

        self.Thaw()

   291

   292

class WidgetPicker(wx.TreeCtrl):

   293

    def __init__(self, parent, initialdir=None):

   294

        wx.TreeCtrl.__init__(self, parent, style=(

   295

            wx.TR_MULTIPLE |

   296

            wx.TR_HAS_BUTTONS |

   297

            wx.SUNKEN_BORDER |

   298

            wx.TR_LINES_AT_ROOT))

   299

   300

        self.MakeTree(initialdir)

   301

   302

    def _recurseTree(self, current_dir, current_tc_root, dirlist):

   303

        """

   304

        recurse through subdirectories, but creates tree nodes 

   305

        only when (sub)directory conbtains .svg file

   306

        """

   307

        res = []

   308

        for f in sorted(os.listdir(current_dir)):

   309

            p = os.path.join(current_dir,f)

   310

            if os.path.isdir(p):

   311

   312

                r = self._recurseTree(p, current_tc_root, dirlist + [f])

   313

                if len(r) > 0 :

   314

                    res = r

   315

                    dirlist = []

   316

                    current_tc_root = res.pop()

   317

   318

            elif os.path.splitext(f)[1].upper() == ".SVG":

   319

                if len(dirlist) > 0 :

   320

                    res = []

   321

                    for d in dirlist:

   322

                        current_tc_root = self.AppendItem(current_tc_root, d)

   323

                        res.append(current_tc_root)

   324

                        self.SetPyData(current_tc_root, None)

   325

                    dirlist = []

   326

                    res.pop()

   327

                tc_child = self.AppendItem(current_tc_root, f)

   328

                self.SetPyData(tc_child, p)

   329

        return res

   330

   331

    def MakeTree(self, lib_dir = None):

   332

        global hmi_tree_root

   333

   334

        self.Freeze()

   335

   336

        self.root = None

   337

        self.DeleteAllItems()

   338

   339

        root_display_name = _("Please select widget library directory") \

   340

            if lib_dir is None else os.path.basename(lib_dir)

   341

        self.root = self.AddRoot(root_display_name)

   342

        self.SetPyData(self.root, None)

   343

   344

        if lib_dir is not None:

   345

            self._recurseTree(lib_dir, self.root, [])

   346

            self.Expand(self.root)

   347

   348

        self.Thaw()

   349

   350

_conf_key = "SVGHMIWidgetLib"

   351

_preview_height = 200

   352

class WidgetLibBrowser(wx.Panel):

   353

    def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,

   354

                 size=wx.DefaultSize):

   355

   356

        wx.Panel.__init__(self, parent, id, pos, size)     

   357

   358

        self.bmp = None

   359

        self.msg = None

   360

        self.hmitree_node = None

   361

        self.selected_SVG = None

   362

   363

        self.Config = wx.ConfigBase.Get()

   364

        self.libdir = self.RecallLibDir()

   365

   366

        sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=3, vgap=0)

   367

        sizer.AddGrowableCol(0)

   368

        sizer.AddGrowableRow(1)

   369

        self.libbutton = wx.Button(self, -1, _("Select SVG widget library"))

   370

        self.widgetpicker = WidgetPicker(self, self.libdir)

   371

        self.preview = wx.Panel(self, size=(-1, _preview_height + 10))  #, style=wx.SIMPLE_BORDER)

   372

        #self.preview.SetBackgroundColour(wx.WHITE)

   373

        sizer.AddWindow(self.libbutton, flag=wx.GROW)

   374

        sizer.AddWindow(self.widgetpicker, flag=wx.GROW)

   375

        sizer.AddWindow(self.preview, flag=wx.GROW)

   376

        sizer.Layout()

   377

        self.SetAutoLayout(True)

   378

        self.SetSizer(sizer)

   379

        sizer.Fit(self)

   380

        self.Bind(wx.EVT_BUTTON, self.OnSelectLibDir, self.libbutton)

   381

        self.preview.Bind(wx.EVT_PAINT, self.OnPaint)

   382

   383

        self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnWidgetSelection, self.widgetpicker)

   384

   385

        self.msg = _("Drag selected Widget from here to Inkscape")

   386

   387

    def RecallLibDir(self):

   388

        conf = self.Config.Read(_conf_key)

   389

        if len(conf) == 0:

   390

            return None

   391

        else:

   392

            return DecodeFileSystemPath(conf)

   393

   394

    def RememberLibDir(self, path):

   395

        self.Config.Write(_conf_key,

   396

                          EncodeFileSystemPath(path))

   397

        self.Config.Flush()

   398

   399

    def DrawPreview(self):

   400

        """

   401

        Refresh preview panel 

   402

        """

   403

        # Init preview panel paint device context

   404

        dc = wx.PaintDC(self.preview)

   405

        dc.Clear()

   406

   407

        if self.bmp:

   408

            # Get Preview panel size

   409

            sz = self.preview.GetClientSize()

   410

            w = self.bmp.GetWidth()

   411

            dc.DrawBitmap(self.bmp, (sz.width - w)/2, 5)

   412

   413

        if self.msg:

   414

            dc.SetFont(self.GetFont())

   415

            dc.DrawText(self.msg, 25,25)

   416

   417

   418

    def OnSelectLibDir(self, event):

   419

        defaultpath = self.RecallLibDir()

   420

        if defaultpath == None:

   421

            defaultpath = os.path.expanduser("~")

   422

   423

        dialog = wx.DirDialog(self, _("Choose a widget library"), defaultpath,

   424

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   425

   426

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

   427

            self.libdir = dialog.GetPath()

   428

            self.RememberLibDir(self.libdir)

   429

            self.widgetpicker.MakeTree(self.libdir)

   430

   431

        dialog.Destroy()

   432

   433

    def OnPaint(self, event):

   434

        """

   435

        Called when Preview panel needs to be redrawn

   436

        @param event: wx.PaintEvent

   437

        """

   438

        self.DrawPreview()

   439

        event.Skip()

   440

   441

    def GenThumbnail(self, svgpath, thumbpath):

   442

        inkpath = get_inkscape_path()

   443

        if inkpath is None:

   444

            self.msg = _("Inkscape is not installed.")

   445

            return False

   446

        # TODO: spawn a thread, to decouple thumbnail gen

   447

        status, result, _err_result = ProcessLogger(

   448

            None,

   449

            '"' + inkpath + '" "' + svgpath + '" -e "' + thumbpath +

   450

            '" -D -h ' + str(_preview_height)).spin()

   451

        if status != 0:

   452

            self.msg = _("Inkscape couldn't generate thumbnail.")

   453

            return False

   454

        return True

   455

   456

    def OnWidgetSelection(self, event):

   457

        """

   458

        Called when tree item is selected

   459

        @param event: wx.TreeEvent

   460

        """

   461

        item_pydata = self.widgetpicker.GetPyData(event.GetItem())

   462

        if item_pydata is not None:

   463

            svgpath = item_pydata

   464

            dname = os.path.dirname(svgpath)

   465

            fname = os.path.basename(svgpath)

   466

            hasher = hashlib.new('md5')

   467

            with open(svgpath, 'rb') as afile:

   468

                while True:

   469

                    buf = afile.read(65536)

   470

                    if len(buf) > 0:

   471

                        hasher.update(buf)

   472

                    else:

   473

                        break

   474

            digest = hasher.hexdigest()

   475

            thumbfname = os.path.splitext(fname)[0]+"_"+digest+".png"

   476

            thumbdir = os.path.join(dname, ".svghmithumbs") 

   477

            thumbpath = os.path.join(thumbdir, thumbfname) 

   478

   479

            self.msg = None

   480

            have_thumb = os.path.exists(thumbpath)

   481

   482

            if not have_thumb:

   483

                try:

   484

                    if not os.path.exists(thumbdir):

   485

                        os.mkdir(thumbdir)

   486

                except IOError:

   487

                    self.msg = _("Widget library must be writable")

   488

                else:

   489

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   490