1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz

     5

# Copyright (C) 2021: Edouard TISSERANT

     6

#

     7

# See COPYING file for copyrights details.

     8

     9

from __future__ import absolute_import

    10

import os

    11

import hashlib

    12

import weakref

    13

from tempfile import NamedTemporaryFile

    14

    15

import wx

    16

    17

from lxml import etree

    18

from lxml.etree import XSLTApplyError

    19

from XSLTransform import XSLTransform

    20

    21

import util.paths as paths

    22

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    23

from docutil import get_inkscape_path

    24

    25

from util.ProcessLogger import ProcessLogger

    26

    27

ScriptDirectory = paths.AbsDir(__file__)

    28

    29

class HMITreeSelector(wx.TreeCtrl):

    30

    def __init__(self, parent):

    31

        global on_hmitree_update

    32

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

    33

            wx.TR_MULTIPLE |

    34

            wx.TR_HAS_BUTTONS |

    35

            wx.SUNKEN_BORDER |

    36

            wx.TR_LINES_AT_ROOT))

    37

    38

        self.MakeTree()

    39

    40

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    41

        for c in current_hmitree_root.children:

    42

            if hasattr(c, "children"):

    43

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

    44

                               if c.hmiclass is not None else c.name

    45

                tc_child = self.AppendItem(current_tc_root, display_name)

    46

                self.SetPyData(tc_child, c)

    47

    48

                self._recurseTree(c,tc_child)

    49

            else:

    50

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

    51

                tc_child = self.AppendItem(current_tc_root, display_name)

    52

                self.SetPyData(tc_child, c)

    53

    54

    def MakeTree(self, hmi_tree_root=None):

    55

    56

        self.Freeze()

    57

    58

        self.root = None

    59

        self.DeleteAllItems()

    60

    61

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

    62

            if hmi_tree_root is None else "HMI"

    63

        self.root = self.AddRoot(root_display_name)

    64

        self.SetPyData(self.root, hmi_tree_root)

    65

    66

        if hmi_tree_root is not None:

    67

            self._recurseTree(hmi_tree_root, self.root)

    68

            self.Expand(self.root)

    69

    70

        self.Thaw()

    71

    72

class WidgetPicker(wx.TreeCtrl):

    73

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

    74

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

    75

            wx.TR_MULTIPLE |

    76

            wx.TR_HAS_BUTTONS |

    77

            wx.SUNKEN_BORDER |

    78

            wx.TR_LINES_AT_ROOT))

    79

    80

        self.MakeTree(initialdir)

    81

    82

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

    83

        """

    84

        recurse through subdirectories, but creates tree nodes 

    85

        only when (sub)directory conbtains .svg file

    86

        """

    87

        res = []

    88

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

    89

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

    90

            if os.path.isdir(p):

    91

    92

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

    93

                if len(r) > 0 :

    94

                    res = r

    95

                    dirlist = []

    96

                    current_tc_root = res.pop()

    97

    98

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

    99

                if len(dirlist) > 0 :

   100

                    res = []

   101

                    for d in dirlist:

   102

                        current_tc_root = self.AppendItem(current_tc_root, d)

   103

                        res.append(current_tc_root)

   104

                        self.SetPyData(current_tc_root, None)

   105

                    dirlist = []

   106

                    res.pop()

   107

                tc_child = self.AppendItem(current_tc_root, f)

   108

                self.SetPyData(tc_child, p)

   109

        return res

   110

   111

    def MakeTree(self, lib_dir = None):

   112

   113

        self.Freeze()

   114

   115

        self.root = None

   116

        self.DeleteAllItems()

   117

   118

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

   119

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

   120

        self.root = self.AddRoot(root_display_name)

   121

        self.SetPyData(self.root, None)

   122

   123

        if lib_dir is not None:

   124

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

   125

            self.Expand(self.root)

   126

   127

        self.Thaw()

   128

   129

_conf_key = "SVGHMIWidgetLib"

   130

_preview_height = 200

   132

class WidgetLibBrowser(wx.Panel):

   133

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

   134

                 size=wx.DefaultSize):

   135

   136

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

   137

   138

        self.bmp = None

   139

        self.msg = None

   140

        self.hmitree_node = None

   141

        self.selected_SVG = None

   142

   143

        self.Config = wx.ConfigBase.Get()

   144

        self.libdir = self.RecallLibDir()

   145

   149

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

   150

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

   153

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   154

        self.signature_sizer = wx.BoxSizer(wx.VERTICAL)

   161

        self.SetAutoLayout(True)

   164

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

   165

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

   166

        self.preview.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)

   167

   168

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

   169

   170

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

   171

        self.tempf = None 

   172

   188

    def RecallLibDir(self):

   189

        conf = self.Config.Read(_conf_key)

   190

        if len(conf) == 0:

   191

            return None

   192

        else:

   193

            return DecodeFileSystemPath(conf)

   194

   195

    def RememberLibDir(self, path):

   196

        self.Config.Write(_conf_key,

   197

                          EncodeFileSystemPath(path))

   198

        self.Config.Flush()

   199

   200

    def DrawPreview(self):

   201

        """

   202

        Refresh preview panel 

   203

        """

   204

        # Init preview panel paint device context

   205

        dc = wx.PaintDC(self.preview)

   206

        dc.Clear()

   207

   208

        if self.bmp:

   209

            # Get Preview panel size

   210

            sz = self.preview.GetClientSize()

   211

            w = self.bmp.GetWidth()

   213

   214

        self.desc.SetValue(self.msg)

   215

   216

   217

    def OnSelectLibDir(self, event):

   218

        defaultpath = self.RecallLibDir()

   219

        if defaultpath == None:

   220

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

   221

   222

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

   223

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   224

   225

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

   226

            self.libdir = dialog.GetPath()

   227

            self.RememberLibDir(self.libdir)

   228

            self.widgetpicker.MakeTree(self.libdir)

   229

   230

        dialog.Destroy()

   231

   232

    def OnPaint(self, event):

   233

        """

   234

        Called when Preview panel needs to be redrawn

   235

        @param event: wx.PaintEvent

   236

        """

   237

        self.DrawPreview()

   238

        event.Skip()

   239

   240

    def GenThumbnail(self, svgpath, thumbpath):

   241

        inkpath = get_inkscape_path()

   242

        if inkpath is None:

   243

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

   244

            return False

   245

        # TODO: spawn a thread, to decouple thumbnail gen

   246

        status, result, _err_result = ProcessLogger(

   247

            None,

   248

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

   249

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

   250

        if status != 0:

   251

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

   252

            return False

   253

        return True

   254

   255

    def OnWidgetSelection(self, event):

   256

        """

   257

        Called when tree item is selected

   258

        @param event: wx.TreeEvent

   259

        """

   260

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

   261

        if item_pydata is not None:

   262

            svgpath = item_pydata

   263

            dname = os.path.dirname(svgpath)

   264

            fname = os.path.basename(svgpath)

   265

            hasher = hashlib.new('md5')

   266

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

   267

                while True:

   268

                    buf = afile.read(65536)

   269

                    if len(buf) > 0:

   270

                        hasher.update(buf)

   271

                    else:

   272

                        break

   273

            digest = hasher.hexdigest()

   274

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

   275

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

   276

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

   277

   278

            have_thumb = os.path.exists(thumbpath)

   279

   280

            try:

   281

                if not have_thumb:

   282

                    if not os.path.exists(thumbdir):

   283

                        os.mkdir(thumbdir)

   284

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   285

   286

                self.bmp = wx.Bitmap(thumbpath) if have_thumb else None

   287

   288

                self.selected_SVG = svgpath if have_thumb else None

   292

            except IOError:

   293

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

   294

   295

            self.Refresh()

   296

        event.Skip()

   297

   298

    def OnHMITreeNodeSelection(self, hmitree_nodes):

   299

        self.hmitree_node = hmitree_nodes[0] if len(hmitree_nodes) else None

   300

        self.ValidateWidget()

   301

        self.Refresh()

   302

   303

    def OnLeftDown(self, evt):

   304

        if self.tempf is not None:

   305

            filename = self.tempf.name

   306

            data = wx.FileDataObject()

   307

            data.AddFile(filename)

   308

            dropSource = wx.DropSource(self)

   309

            dropSource.SetData(data)

   310

            dropSource.DoDragDrop(wx.Drag_AllowMove)

   311

   312

    def GiveDetails(self, _context, msgs):

   313

        for msg in msgs:

   314

            self.msg += msg.text + "\n"

   315

   316

    def PassMessage(self, _context, msgs):

   317

        for msg in msgs:

   318

            self.msg += msg.text + "\n"

   319

   320

    def GetSubHMITree(self, _context):

   321

        return [self.hmitree_node.etree()]

   324

        self.msg = ""

   325

   326

        try:

   327

            if self.selected_SVG is None:

   328

                raise Exception(_("No widget selected"))

   329

   330

            transform = XSLTransform(

   331

                os.path.join(ScriptDirectory, "analyse_widget.xslt"),[])

   332

   333

            svgdom = etree.parse(self.selected_SVG)

   334

   336

   337

            for entry in transform.get_error_log():

   338

                self.msg += "XSLT: " + entry.message + "\n" 

   339

   340

        except Exception as e:

   341

            self.msg += str(e)

   342

        except XSLTApplyError as e:

   343

            self.msg += "Widget analysis error: " + e.message

   344

        else:

   348

            print(etree.tostring(signature, pretty_print=True))

   349

            widgets = signature.getroot()

   364

            for widget in widgets:

   365

                widget_type = widget.get("type")

   366

                print(widget_type)

   368

                    path_value = path.get("value")

   369

                    path_accepts = map(

   370

                        str.strip, path.get("accepts", '')[1:-1].split(','))

   372

   373

   374

   375

    def ValidateWidget(self):

   376

        self.msg = ""

   377

   378

        if self.tempf is not None:

   379

            os.unlink(self.tempf.name)

   380

            self.tempf = None

   381

   382

        try:

   383

            if self.selected_SVG is None:

   384

                raise Exception(_("No widget selected"))

   385

            if self.hmitree_node is None:

   386

                raise Exception(_("No HMI tree node selected"))

   387

   388

            transform = XSLTransform(

   389

                os.path.join(ScriptDirectory, "gen_dnd_widget_svg.xslt"),

   390

                [("GetSubHMITree", self.GetSubHMITree),

   391

                 ("PassMessage", self.GiveDetails)])

   392

   393

            svgdom = etree.parse(self.selected_SVG)

   394

   395

            result = transform.transform(

   396

                svgdom, hmi_path = self.hmitree_node.hmi_path())

   397

   398

            for entry in transform.get_error_log():

   399

                self.msg += "XSLT: " + entry.message + "\n" 

   400

   401

            self.tempf = NamedTemporaryFile(suffix='.svg', delete=False)

   402

            result.write(self.tempf, encoding="utf-8")

   403

            self.tempf.close()

   404

   405

        except Exception as e:

   406

            self.msg += str(e)

   407

        except XSLTApplyError as e:

   408

            self.msg += "Widget transform error: " + e.message

   409

   410

    def __del__(self):

   411

        if self.tempf is not None:

   412

            os.unlink(self.tempf.name)

   413

   414

class SVGHMI_UI(wx.SplitterWindow):

   415

   416

    def __init__(self, parent, register_for_HMI_tree_updates):

   417

        wx.SplitterWindow.__init__(self, parent,

   418

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   419

   420

        self.ordered_items = []

   421

   422

        self.SelectionTree = HMITreeSelector(self)

   423

        self.Staging = WidgetLibBrowser(self)

   424

        self.SplitVertically(self.SelectionTree, self.Staging, 300)

   425

        register_for_HMI_tree_updates(weakref.ref(self))

   426

        self.Bind(wx.EVT_TREE_SEL_CHANGED,

   427

            self.OnHMITreeNodeSelection, self.SelectionTree)

   428

   429

    def OnHMITreeNodeSelection(self, event):

   430

        items = self.SelectionTree.GetSelections()

   431

        items_pydata = [self.SelectionTree.GetPyData(item) for item in items]

   432

   433

        # append new items to ordered item list

   434

        for item_pydata in items_pydata:

   435

            if item_pydata not in self.ordered_items:

   436

                self.ordered_items.append(item_pydata)

   437

   438

        # filter out vanished items

   439

        self.ordered_items = [

   440

            item_pydata 

   441

            for item_pydata in self.ordered_items 

   442

            if item_pydata in items_pydata]

   443

   444

        self.Staging.OnHMITreeNodeSelection(items_pydata)

   445

   446

    def HMITreeUpdate(self, hmi_tree_root):

   447

            self.SelectionTree.MakeTree(hmi_tree_root)

   448