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

import re

    14

from threading import Thread, Lock

    15

from functools import reduce

    16

from itertools import izip

    17

from operator import or_

    18

from tempfile import NamedTemporaryFile

    19

    20

import wx

    21

from wx.lib.scrolledpanel import ScrolledPanel

    22

    23

from lxml import etree

    24

from lxml.etree import XSLTApplyError

    25

from XSLTransform import XSLTransform

    26

    27

import util.paths as paths

    28

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    29

from docutil import get_inkscape_path

    30

    31

from util.ProcessLogger import ProcessLogger

    32

    33

ScriptDirectory = paths.AbsDir(__file__)

    34

    35

HMITreeDndMagicWord = "text/beremiz-hmitree"

    36

    37

class HMITreeSelector(wx.TreeCtrl):

    38

    def __init__(self, parent):

    39

    40

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

    41

            wx.TR_MULTIPLE |

    42

            wx.TR_HAS_BUTTONS |

    43

            wx.SUNKEN_BORDER |

    44

            wx.TR_LINES_AT_ROOT))

    45

    46

        self.ordered_items = []

    47

        self.parent = parent

    48

    49

        self.MakeTree()

    50

    51

        self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnTreeNodeSelection)

    52

        self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnTreeBeginDrag)

    53

    54

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    55

        for c in current_hmitree_root.children:

    56

            if hasattr(c, "children"):

    57

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

    58

                               if c.hmiclass is not None else c.name

    59

                tc_child = self.AppendItem(current_tc_root, display_name)

    60

                self.SetPyData(tc_child, c)

    61

    62

                self._recurseTree(c,tc_child)

    63

            else:

    64

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

    65

                tc_child = self.AppendItem(current_tc_root, display_name)

    66

                self.SetPyData(tc_child, c)

    67

    68

    def OnTreeNodeSelection(self, event):

    69

        items = self.GetSelections()

    70

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

    71

    72

        # append new items to ordered item list

    73

        for item_pydata in items_pydata:

    74

            if item_pydata not in self.ordered_items:

    75

                self.ordered_items.append(item_pydata)

    76

    77

        # filter out vanished items

    78

        self.ordered_items = [

    79

            item_pydata 

    80

            for item_pydata in self.ordered_items 

    81

            if item_pydata in items_pydata]

    82

    83

        self.parent.OnHMITreeNodeSelection(self.ordered_items)

    84

    85

    def OnTreeBeginDrag(self, event):

    86

        """

    87

        Called when a drag is started in tree

    88

        @param event: wx.TreeEvent

    89

        """

    90

        if self.ordered_items:

    91

            # Just send a recognizable mime-type, drop destination

    92

            # will get python data from parent

    93

            data = wx.CustomDataObject(HMITreeDndMagicWord)

    94

            dragSource = wx.DropSource(self)

    95

            dragSource.SetData(data)

    96

            dragSource.DoDragDrop()

    97

    98

    def MakeTree(self, hmi_tree_root=None):

    99

   100

        self.Freeze()

   101

   102

        self.root = None

   103

        self.DeleteAllItems()

   104

   105

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

   106

            if hmi_tree_root is None else "HMI"

   107

        self.root = self.AddRoot(root_display_name)

   108

        self.SetPyData(self.root, hmi_tree_root)

   109

   110

        if hmi_tree_root is not None:

   111

            self._recurseTree(hmi_tree_root, self.root)

   112

            self.Expand(self.root)

   113

   114

        self.Thaw()

   115

   116

class WidgetPicker(wx.TreeCtrl):

   117

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

   118

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

   119

            wx.TR_MULTIPLE |

   120

            wx.TR_HAS_BUTTONS |

   121

            wx.SUNKEN_BORDER |

   122

            wx.TR_LINES_AT_ROOT))

   123

   124

        self.MakeTree(initialdir)

   125

   126

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

   127

        """

   128

        recurse through subdirectories, but creates tree nodes 

   129

        only when (sub)directory conbtains .svg file

   130

        """

   131

        res = []

   132

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

   133

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

   134

            if os.path.isdir(p):

   135

   136

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

   137

                if len(r) > 0 :

   138

                    res = r

   139

                    dirlist = []

   140

                    current_tc_root = res.pop()

   141

   142

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

   143

                if len(dirlist) > 0 :

   144

                    res = []

   145

                    for d in dirlist:

   146

                        current_tc_root = self.AppendItem(current_tc_root, d)

   147

                        res.append(current_tc_root)

   148

                        self.SetPyData(current_tc_root, None)

   149

                    dirlist = []

   150

                    res.pop()

   151

                tc_child = self.AppendItem(current_tc_root, f)

   152

                self.SetPyData(tc_child, p)

   153

        return res

   154

   155

    def MakeTree(self, lib_dir = None):

   156

   157

        self.Freeze()

   158

   159

        self.root = None

   160

        self.DeleteAllItems()

   161

   162

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

   163

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

   164

        self.root = self.AddRoot(root_display_name)

   165

        self.SetPyData(self.root, None)

   166

   167

        if lib_dir is not None and os.path.exists(lib_dir):

   168

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

   169

            self.Expand(self.root)

   170

   171

        self.Thaw()

   172

   173

class PathDropTarget(wx.DropTarget):

   174

   175

    def __init__(self, parent):

   176

        data = wx.CustomDataObject(HMITreeDndMagicWord)

   177

        wx.DropTarget.__init__(self, data)

   178

        self.ParentWindow = parent

   179

   180

    def OnDrop(self, x, y):

   181

        self.ParentWindow.OnHMITreeDnD()

   182

        return True

   183

   184

class ParamEditor(wx.Panel):

   185

    def __init__(self, parent, paramdesc):

   186

        wx.Panel.__init__(self, parent.main_panel)

   187

        label = paramdesc.get("name")+ ": " + paramdesc.get("accepts") 

   188

        if paramdesc.text:

   189

            label += "\n\"" + paramdesc.text + "\""

   190

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

   191

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

   192

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

   193

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

   194

        self.edit = wx.TextCtrl(self)

   195

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

   196

        self.edit_sizer.AddGrowableCol(0)

   197

        self.edit_sizer.AddGrowableRow(0)

   198

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

   199

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

   200

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

   201

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

   202

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

   203

        self.SetSizer(self.main_sizer)

   204

        self.main_sizer.Fit(self)

   205

   206

    def GetValue(self):

   207

        return self.edit.GetValue()

   208

   209

    def setValidity(self, validity):

   210

        if validity is not None:

   211

            bmp = self.valid_bmp if validity else self.invalid_bmp

   212

            self.validity_sbmp.SetBitmap(bmp)

   213

            self.validity_sbmp.Show(True)

   214

        else :

   215

            self.validity_sbmp.Show(False)

   216

   217

models = { typename: re.compile(regex) for typename, regex in [

   218

    ("string", r".*"),

   219

    ("int", r"^-?([1-9][0-9]*|0)$"),

   220

    ("real", r"^-?([1-9][0-9]*|0)(\.[0-9]+)?$")]}

   221

   222

class ArgEditor(ParamEditor):

   223

    def __init__(self, parent, argdesc, prefillargdesc):

   224

        ParamEditor.__init__(self, parent, argdesc)

   225

        self.ParentObj = parent

   226

        self.argdesc = argdesc

   227

        self.Bind(wx.EVT_TEXT, self.OnArgChanged, self.edit)

   228

        prefill = "" if prefillargdesc is None else prefillargdesc.get("value")

   229

        self.edit.SetValue(prefill)

   230

        # TODO add a button to add more ArgEditror instance 

   231

        #      when ordinality is multiple

   232

   233

    def OnArgChanged(self, event):

   234

        txt = self.edit.GetValue()

   235

        accepts = self.argdesc.get("accepts").split(',')

   236

        self.setValidity(

   237

            reduce(or_,

   238

                   map(lambda typename: 

   239

                           models[typename].match(txt) is not None,

   240

                       accepts), 

   241

                   False)

   242

            if accepts and txt else None)

   243

        self.ParentObj.RegenSVGLater()

   244

        event.Skip()

   245

   246

class PathEditor(ParamEditor):

   247

    def __init__(self, parent, pathdesc):

   248

        ParamEditor.__init__(self, parent, pathdesc)

   249

        self.ParentObj = parent

   250

        self.pathdesc = pathdesc

   251

        DropTarget = PathDropTarget(self)

   252

        self.edit.SetDropTarget(DropTarget)

   253

        self.edit.SetHint(_("Drag'n'drop HMI variable here"))

   254

        self.Bind(wx.EVT_TEXT, self.OnPathChanged, self.edit)

   255

   256

    def OnHMITreeDnD(self):

   257

        self.ParentObj.GotPathDnDOn(self)

   258

   259

    def SetPath(self, hmitree_node):

   260

        self.edit.ChangeValue(hmitree_node.hmi_path())

   261

        self.setValidity(

   262

            hmitree_node.nodetype in self.pathdesc.get("accepts").split(","))

   263

   264

    def OnPathChanged(self, event):

   265

        # TODO : find corresponding hmitre node and type to update validity

   266

        # Lazy way : hide validity

   267

        self.setValidity(None)

   268

        self.ParentObj.RegenSVGLater()

   269

        event.Skip()

   270

   271

def KeepDoubleNewLines(txt):

   272

    return "\n\n".join(map(

   273

        lambda s:re.sub(r'\s+',' ',s),

   274

        txt.split("\n\n")))

   275

   276

_conf_key = "SVGHMIWidgetLib"

   277

_preview_height = 200

   278

_preview_margin = 5

   279

class WidgetLibBrowser(wx.SplitterWindow):

   280

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

   281

                 size=wx.DefaultSize):

   282

   283

        wx.SplitterWindow.__init__(self, parent,

   284

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   285

   286

        self.bmp = None

   287

        self.msg = None

   288

        self.hmitree_nodes = []

   289

        self.selected_SVG = None

   290

   291

        self.Config = wx.ConfigBase.Get()

   292

        self.libdir = self.RecallLibDir()

   293

   294

        self.picker_desc_splitter = wx.SplitterWindow(self, style=wx.SUNKEN_BORDER | wx.SP_3D)

   295

   296

        self.picker_panel = wx.Panel(self.picker_desc_splitter)

   297

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

   298

        self.picker_sizer.AddGrowableCol(0)

   299

        self.picker_sizer.AddGrowableRow(1)

   300

   301

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

   302

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

   303

   304

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

   305

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

   306

        self.picker_sizer.Layout()

   307

        self.picker_panel.SetAutoLayout(True)

   308

        self.picker_panel.SetSizer(self.picker_sizer)

   309

   310

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

   311

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

   312

   313

   314

   315

        self.main_panel = ScrolledPanel(parent=self,

   316

                                                name='MiscellaneousPanel',

   317

                                                style=wx.TAB_TRAVERSAL)

   318

   319

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

   320

        self.main_sizer.AddGrowableCol(0)

   321

        self.main_sizer.AddGrowableRow(2)

   322

   323

        self.staticmsg = wx.StaticText(self, label = _("Drag selected Widget from here to Inkscape"))

   324

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

   325

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

   326

        self.args_box = wx.StaticBox(self.main_panel, -1,

   327

                                     _("Widget's arguments"),

   328

                                     style = wx.ALIGN_CENTRE_HORIZONTAL)

   329

        self.args_sizer = wx.StaticBoxSizer(self.args_box, wx.VERTICAL)

   330

        self.paths_box = wx.StaticBox(self.main_panel, -1,

   331

                                      _("Widget's variables"),

   332

                                      style = wx.ALIGN_CENTRE_HORIZONTAL)

   333

        self.paths_sizer = wx.StaticBoxSizer(self.paths_box, wx.VERTICAL)

   334

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

   335

        self.signature_sizer.AddSpacer(5)

   336

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

   337

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

   338

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

   339

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

   340

        self.main_sizer.Layout()

   341

        self.main_panel.SetAutoLayout(True)

   342

        self.main_panel.SetSizer(self.main_sizer)

   343

        self.main_sizer.Fit(self.main_panel)

   344

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

   345

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

   346

   347

        self.desc = wx.TextCtrl(self.picker_desc_splitter, size=wx.Size(-1, 160),

   348

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   349

   350

        self.picker_desc_splitter.SplitHorizontally(self.picker_panel, self.desc, 400)

   351

        self.SplitVertically(self.main_panel, self.picker_desc_splitter, 300)

   352

   353

        self.tempf = None 

   354

   355

        self.RegenSVGThread = None

   356

        self.RegenSVGLock = Lock()

   357

        self.RegenSVGTimer = wx.Timer(self, -1)

   358

        self.RegenSVGParams = None

   359

        self.Bind(wx.EVT_TIMER,

   360

                  self.RegenSVG,

   361

                  self.RegenSVGTimer)

   362

   363

        self.args_editors = []

   364

        self.paths_editors = []

   365

   366

    def SetMessage(self, msg):

   367

        self.staticmsg.SetLabel(msg)

   368

        self.main_sizer.Layout()

   369

   370

    def ResetSignature(self):

   371

        self.args_sizer.Clear()

   372

        for editor in self.args_editors:

   373

            editor.Destroy()

   374

        self.args_editors = []

   375

   376

        self.paths_sizer.Clear()

   377

        for editor in self.paths_editors:

   378

            editor.Destroy()

   379

        self.paths_editors = []

   380

   381

    def AddArgToSignature(self, arg, prefillarg):

   382

        new_editor = ArgEditor(self, arg, prefillarg)

   383

        self.args_editors.append(new_editor)

   384

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

   385

   386

    def AddPathToSignature(self, path):

   387

        new_editor = PathEditor(self, path)

   388

        self.paths_editors.append(new_editor)

   389

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

   390

   391

    def GotPathDnDOn(self, target_editor):

   392

        dndindex = self.paths_editors.index(target_editor)

   393

   394

        for hmitree_node,editor in zip(self.hmitree_nodes,

   395

                                   self.paths_editors[dndindex:]):

   396

            editor.SetPath(hmitree_node)

   397

   398

        self.RegenSVGNow()

   399

   400

    def RecallLibDir(self):

   401

        conf = self.Config.Read(_conf_key)

   402

        if len(conf) == 0:

   403

            return None

   404

        else:

   405

            return DecodeFileSystemPath(conf)

   406

   407

    def RememberLibDir(self, path):

   408

        self.Config.Write(_conf_key,

   409

                          EncodeFileSystemPath(path))

   410

        self.Config.Flush()

   411

   412

    def DrawPreview(self):

   413

        """

   414

        Refresh preview panel 

   415

        """

   416

        # Init preview panel paint device context

   417

        dc = wx.PaintDC(self.preview)

   418

        dc.Clear()

   419

   420

        if self.bmp:

   421

            # Get Preview panel size

   422

            sz = self.preview.GetClientSize()

   423

            w = self.bmp.GetWidth()

   424

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

   425

   426

   427

   428

    def OnSelectLibDir(self, event):

   429

        defaultpath = self.RecallLibDir()

   430

        if defaultpath == None:

   431

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

   432

   433

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

   434

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   435

   436

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

   437

            self.libdir = dialog.GetPath()

   438

            self.RememberLibDir(self.libdir)

   439

            self.widgetpicker.MakeTree(self.libdir)

   440

   441

        dialog.Destroy()

   442

   443

    def OnPaint(self, event):

   444

        """

   445

        Called when Preview panel needs to be redrawn

   446

        @param event: wx.PaintEvent

   447

        """

   448

        self.DrawPreview()

   449

        event.Skip()

   450

   451

    def GenThumbnail(self, svgpath, thumbpath):

   452

        inkpath = get_inkscape_path()

   453

        if inkpath is None:

   454

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

   455

            return False

   456

        # TODO: spawn a thread, to decouple thumbnail gen

   457

        status, result, _err_result = ProcessLogger(

   458

            None,

   459

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

   460

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

   461

        if status != 0:

   462

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

   463

            return False

   464

        return True

   465

   466

    def OnWidgetSelection(self, event):

   467

        """

   468

        Called when tree item is selected

   469

        @param event: wx.TreeEvent

   470

        """

   471

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

   472

        if item_pydata is not None:

   473

            svgpath = item_pydata

   474

            dname = os.path.dirname(svgpath)

   475

            fname = os.path.basename(svgpath)

   476

            hasher = hashlib.new('md5')

   477

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

   478

                while True:

   479

                    buf = afile.read(65536)

   480

                    if len(buf) > 0:

   481

                        hasher.update(buf)

   482

                    else:

   483

                        break

   484

            digest = hasher.hexdigest()

   485

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

   486

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

   487

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

   488

   489

            have_thumb = os.path.exists(thumbpath)