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

    17

    18

from lxml import etree

    19

from lxml.etree import XSLTApplyError

    20

from XSLTransform import XSLTransform

    21

    22

import util.paths as paths

    23

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    24

from docutil import get_inkscape_path

    25

    26

from util.ProcessLogger import ProcessLogger

    27

    28

ScriptDirectory = paths.AbsDir(__file__)

    29

    30

class HMITreeSelector(wx.TreeCtrl):

    31

    def __init__(self, parent):

    32

        global on_hmitree_update

    33

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

    34

            wx.TR_MULTIPLE |

    35

            wx.TR_HAS_BUTTONS |

    36

            wx.SUNKEN_BORDER |

    37

            wx.TR_LINES_AT_ROOT))

    38

    39

        self.MakeTree()

    40

    41

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    42

        for c in current_hmitree_root.children:

    43

            if hasattr(c, "children"):

    44

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

    45

                               if c.hmiclass is not None else c.name

    46

                tc_child = self.AppendItem(current_tc_root, display_name)

    47

                self.SetPyData(tc_child, c)

    48

    49

                self._recurseTree(c,tc_child)

    50

            else:

    51

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

    52

                tc_child = self.AppendItem(current_tc_root, display_name)

    53

                self.SetPyData(tc_child, c)

    54

    55

    def MakeTree(self, hmi_tree_root=None):

    56

    57

        self.Freeze()

    58

    59

        self.root = None

    60

        self.DeleteAllItems()

    61

    62

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

    63

            if hmi_tree_root is None else "HMI"

    64

        self.root = self.AddRoot(root_display_name)

    65

        self.SetPyData(self.root, hmi_tree_root)

    66

    67

        if hmi_tree_root is not None:

    68

            self._recurseTree(hmi_tree_root, self.root)

    69

            self.Expand(self.root)

    70

    71

        self.Thaw()

    72

    73

class WidgetPicker(wx.TreeCtrl):

    74

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

    75

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

    76

            wx.TR_MULTIPLE |

    77

            wx.TR_HAS_BUTTONS |

    78

            wx.SUNKEN_BORDER |

    79

            wx.TR_LINES_AT_ROOT))

    80

    81

        self.MakeTree(initialdir)

    82

    83

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

    84

        """

    85

        recurse through subdirectories, but creates tree nodes 

    86

        only when (sub)directory conbtains .svg file

    87

        """

    88

        res = []

    89

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

    90

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

    91

            if os.path.isdir(p):

    92

    93

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

    94

                if len(r) > 0 :

    95

                    res = r

    96

                    dirlist = []

    97

                    current_tc_root = res.pop()

    98

    99

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

   100

                if len(dirlist) > 0 :

   101

                    res = []

   102

                    for d in dirlist:

   103

                        current_tc_root = self.AppendItem(current_tc_root, d)

   104

                        res.append(current_tc_root)

   105

                        self.SetPyData(current_tc_root, None)

   106

                    dirlist = []

   107

                    res.pop()

   108

                tc_child = self.AppendItem(current_tc_root, f)

   109

                self.SetPyData(tc_child, p)

   110

        return res

   111

   112

    def MakeTree(self, lib_dir = None):

   113

   114

        self.Freeze()

   115

   116

        self.root = None

   117

        self.DeleteAllItems()

   118

   119

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

   120

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

   121

        self.root = self.AddRoot(root_display_name)

   122

        self.SetPyData(self.root, None)

   123

   124

        if lib_dir is not None:

   125

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

   126

            self.Expand(self.root)

   127

   128

        self.Thaw()

   129

   130

class PathEditor(wx.Panel):

   131

    def __init__(self, parent, path):

   132

   133

        wx.Panel.__init__(self, parent)

   134

        label = path.get("name") + ": " + path.text + "(" + path.get("accepts") + ")"

   135

        self.desc = wx.StaticText(self, label=label)

   136

        self.focus_sbmp = wx.StaticBitmap(self, -1, wx.ArtProvider.GetBitmap(wx.ART_GO_FORWARD, wx.ART_TOOLBAR, (32,32)))

   137

        self.valid_bmp = wx.ArtProvider.GetBitmap(wx.ART_TICK_MARK, wx.ART_TOOLBAR, (32,32))

   138

        self.invalid_bmp = wx.ArtProvider.GetBitmap(wx.ART_CROSS_MARK, wx.ART_TOOLBAR, (32,32))

   139

        self.validity_sbmp = wx.StaticBitmap(self, -1, self.invalid_bmp)

   140

        self.edit = wx.TextCtrl(self)

   141

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

   142

        self.edit_sizer.AddGrowableCol(1)

   143

        self.edit_sizer.AddGrowableRow(0)

   144

        self.edit_sizer.Add(self.focus_sbmp, flag=wx.GROW)

   145

        self.edit_sizer.Add(self.edit, flag=wx.GROW)

   146

        self.edit_sizer.Add(self.validity_sbmp, flag=wx.GROW)

   147

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

   148

        self.main_sizer.Add(self.desc, flag=wx.GROW)

   149

        self.main_sizer.Add(self.edit_sizer, flag=wx.GROW)

   150

        self.SetSizer(self.main_sizer)

   151

        self.main_sizer.Fit(self)

   152

   153

_conf_key = "SVGHMIWidgetLib"

   154

_preview_height = 200

   155

_preview_margin = 5

   156

class WidgetLibBrowser(wx.SplitterWindow):

   157

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

   158

                 size=wx.DefaultSize):

   159

   160

        wx.SplitterWindow.__init__(self, parent,

   161

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   162

   163

        self.bmp = None

   164

        self.msg = None

   165

        self.hmitree_node = None

   166

        self.selected_SVG = None

   167

   168

        self.Config = wx.ConfigBase.Get()

   169

        self.libdir = self.RecallLibDir()

   170

   174

        self.picker_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)

   175

        self.picker_sizer.AddGrowableCol(0)

   176

        self.picker_sizer.AddGrowableRow(1)

   177

   178

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

   179

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

   180

   181

        self.picker_sizer.Add(self.libbutton, flag=wx.GROW)

   182

        self.picker_sizer.Add(self.widgetpicker, flag=wx.GROW)

   183

        self.picker_sizer.Layout()

   184

        self.picker_panel.SetAutoLayout(True)

   185

        self.picker_panel.SetSizer(self.picker_sizer)

   186

   187

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

   188

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

   189

   190

   191

   195

   196

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

   197

        self.main_sizer.AddGrowableCol(0)

   198

        self.main_sizer.AddGrowableRow(2)

   199

   200

        self.preview = wx.Panel(self.main_panel, size=(-1, _preview_height + _preview_margin*2))

   202

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

   203

        self.main_sizer.Add(self.preview, flag=wx.GROW)

   205

        self.main_sizer.Add(self.signature_sizer, flag=wx.GROW)

   206

        self.main_sizer.Layout()

   207

        self.main_panel.SetAutoLayout(True)

   208

        self.main_panel.SetSizer(self.main_sizer)

   209

        self.main_sizer.Fit(self.main_panel)

   210

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

   211

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

   212

   218

   219

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

   220

        self.tempf = None 

   221

   222

        self.paths_editors = []

   223

   224

    def ResetSignature(self):

   225

        self.signature_sizer.Clear()

   226

        for editor in self.paths_editors:

   227

            editor.Destroy()

   228

        self.paths_editors = []

   229

   230

    def AddPathToSignature(self, path):

   231

        new_editor = PathEditor(self.main_panel, path)

   232

        self.paths_editors.append(new_editor)

   233

        self.signature_sizer.Add(new_editor, flag=wx.GROW)

   234

   235

    def RecallLibDir(self):

   236

        conf = self.Config.Read(_conf_key)

   237

        if len(conf) == 0:

   238

            return None

   239

        else:

   240

            return DecodeFileSystemPath(conf)

   241

   242

    def RememberLibDir(self, path):

   243

        self.Config.Write(_conf_key,

   244

                          EncodeFileSystemPath(path))

   245

        self.Config.Flush()

   246

   247

    def DrawPreview(self):

   248

        """

   249

        Refresh preview panel 

   250

        """

   251

        # Init preview panel paint device context

   252

        dc = wx.PaintDC(self.preview)

   253

        dc.Clear()

   254

   255

        if self.bmp:

   256

            # Get Preview panel size

   257

            sz = self.preview.GetClientSize()

   258

            w = self.bmp.GetWidth()

   259

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

   260

   261

   262

   263

    def OnSelectLibDir(self, event):

   264

        defaultpath = self.RecallLibDir()

   265

        if defaultpath == None:

   266

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

   267

   268

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

   269

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   270

   271

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

   272

            self.libdir = dialog.GetPath()

   273

            self.RememberLibDir(self.libdir)

   274

            self.widgetpicker.MakeTree(self.libdir)

   275

   276

        dialog.Destroy()

   277

   278

    def OnPaint(self, event):

   279

        """

   280

        Called when Preview panel needs to be redrawn

   281

        @param event: wx.PaintEvent

   282

        """

   283

        self.DrawPreview()

   284

        event.Skip()

   285

   288

    def GenThumbnail(self, svgpath, thumbpath):

   289

        inkpath = get_inkscape_path()

   290

        if inkpath is None:

   291

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

   292

            return False

   293

        # TODO: spawn a thread, to decouple thumbnail gen

   294

        status, result, _err_result = ProcessLogger(

   295

            None,

   296

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

   297

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

   298

        if status != 0:

   299

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

   300

            return False

   301

        return True

   302

   303

    def OnWidgetSelection(self, event):

   304

        """

   305

        Called when tree item is selected

   306

        @param event: wx.TreeEvent

   307

        """

   308

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

   309

        if item_pydata is not None:

   310

            svgpath = item_pydata

   311

            dname = os.path.dirname(svgpath)

   312

            fname = os.path.basename(svgpath)

   313

            hasher = hashlib.new('md5')

   314

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

   315

                while True:

   316

                    buf = afile.read(65536)

   317

                    if len(buf) > 0:

   318

                        hasher.update(buf)

   319

                    else:

   320

                        break

   321

            digest = hasher.hexdigest()

   322

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

   323

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

   324

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

   325

   326

            have_thumb = os.path.exists(thumbpath)

   327

   328

            try:

   329

                if not have_thumb:

   330

                    if not os.path.exists(thumbdir):

   331

                        os.mkdir(thumbdir)

   332

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   333

   334

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

   335

   336

                self.selected_SVG = svgpath if have_thumb else None

   337

   338

                self.AnalyseWidgetAndUpdateUI()

   339

   340

            except IOError:

   341

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

   342

   343

            self.Refresh()

   344

        event.Skip()

   345

   346

    def OnHMITreeNodeSelection(self, hmitree_nodes):

   347

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

   348

        self.ValidateWidget()

   349

        self.Refresh()

   350

   351

    def OnLeftDown(self, evt):

   352

        if self.tempf is not None:

   353

            filename = self.tempf.name

   354

            data = wx.FileDataObject()

   355

            data.AddFile(filename)

   356

            dropSource = wx.DropSource(self)

   357

            dropSource.SetData(data)

   358

            dropSource.DoDragDrop(wx.Drag_AllowMove)

   359

   360

    def GiveDetails(self, _context, msgs):

   361

        for msg in msgs:

   362

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

   363

   364

    def PassMessage(self, _context, msgs):

   365

        for msg in msgs:

   366

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

   367

   368

    def GetSubHMITree(self, _context):

   369

        return [self.hmitree_node.etree()]

   370

   371

    def AnalyseWidgetAndUpdateUI(self):

   372

        self.msg = ""

   374

   375

        try:

   376

            if self.selected_SVG is None:

   377

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

   378

   379

            transform = XSLTransform(

   380

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

   381

   382

            svgdom = etree.parse(self.selected_SVG)

   383

   384

            signature = transform.transform(svgdom)

   385

   386

            for entry in transform.get_error_log():

   387

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

   388

   389

        except Exception as e:

   390

            self.msg += str(e)

   391

        except XSLTApplyError as e:

   392

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

   393

        else:

   394

   395

   396

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

   397

            widgets = signature.getroot()

   398

            for defs in widgets.iter("defs"):

   399

   400

                # Keep double newlines (to mark paragraphs)

   404

                for arg in defs.iter("arg"):

   405

                    print(arg.get("name"))

   406

                    print(arg.get("accepts"))

   407

                for path in defs.iter("path"):

   408

                    self.AddPathToSignature(path)

   409

                    print(path.get("name"))

   410

                    print(path.get("accepts"))

   411

   412

            for widget in widgets:

   413

                widget_type = widget.get("type")

   414

                print(widget_type)

   415

                for path in widget.iterchildren("path"):

   416

                    path_value = path.get("value")

   417

                    path_accepts = map(

   418

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

   419

                    print(path, path_value, path_accepts)

   420

   423

   424

   425

    def ValidateWidget(self):

   426

        self.msg = ""

   427

   428

        if self.tempf is not None:

   429

            os.unlink(self.tempf.name)

   430

            self.tempf = None

   431

   432

        try:

   433

            if self.selected_SVG is None:

   434

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

   435

            if self.hmitree_node is None:

   436

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

   437

   438

            transform = XSLTransform(

   439

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

   440

                [("GetSubHMITree", self.GetSubHMITree),

   441

                 ("PassMessage", self.GiveDetails)])

   442

   443

            svgdom = etree.parse(self.selected_SVG)

   444

   445

            result = transform.transform(

   446

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

   447

   448

            for entry in transform.get_error_log():

   449

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

   450

   451

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

   452

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

   453

            self.tempf.close()

   454

   455

        except Exception as e:

   456

            self.msg += str(e)

   457

        except XSLTApplyError as e:

   458

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

   459

   460

    def __del__(self):

   461

        if self.tempf is not None:

   462

            os.unlink(self.tempf.name)

   463

   464

class SVGHMI_UI(wx.SplitterWindow):

   465

   466

    def __init__(self, parent, register_for_HMI_tree_updates):

   467

        wx.SplitterWindow.__init__(self, parent,

   468

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   469

   470

        self.ordered_items = []

   471

   472

        self.SelectionTree = HMITreeSelector(self)

   473

        self.Staging = WidgetLibBrowser(self)

   474

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

   475

        register_for_HMI_tree_updates(weakref.ref(self))

   476

        self.Bind(wx.EVT_TREE_SEL_CHANGED,

   477

            self.OnHMITreeNodeSelection, self.SelectionTree)

   478

   479

    def OnHMITreeNodeSelection(self, event):

   480

        items = self.SelectionTree.GetSelections()

   481

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

   482

   483

        # append new items to ordered item list

   484

        for item_pydata in items_pydata:

   485

            if item_pydata not in self.ordered_items:

   486

                self.ordered_items.append(item_pydata)

   487

   488

        # filter out vanished items

   489

        self.ordered_items = [

   490