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

        if self.libdir is None:

   294

            self.libdir = os.path.join(ScriptDirectory, "widgetlib") 

   295

   296

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

   297

   298

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

   299

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

   300

        self.picker_sizer.AddGrowableCol(0)

   301

        self.picker_sizer.AddGrowableRow(1)

   302

   303

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

   304

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

   305

   306

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

   307

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

   308

        self.picker_sizer.Layout()

   309

        self.picker_panel.SetAutoLayout(True)

   310

        self.picker_panel.SetSizer(self.picker_sizer)

   311

   312

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

   313

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

   314

   315

   316

   317

        self.main_panel = ScrolledPanel(parent=self,

   318

                                                name='MiscellaneousPanel',

   319

                                                style=wx.TAB_TRAVERSAL)

   320

   321

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

   322

        self.main_sizer.AddGrowableCol(0)

   323

        self.main_sizer.AddGrowableRow(2)

   324

   325

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

   326

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

   327

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

   328

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

   329

                                     _("Widget's arguments"),

   330

                                     style = wx.ALIGN_CENTRE_HORIZONTAL)

   331

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

   332

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

   333

                                      _("Widget's variables"),

   334

                                      style = wx.ALIGN_CENTRE_HORIZONTAL)

   335

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

   336

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

   337

        self.signature_sizer.AddSpacer(5)

   338

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

   339

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

   340

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

   341

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

   342

        self.main_sizer.Layout()

   343

        self.main_panel.SetAutoLayout(True)

   344

        self.main_panel.SetSizer(self.main_sizer)

   345

        self.main_sizer.Fit(self.main_panel)

   346

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

   347

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

   348

   349

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

   350

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   351

   352

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

   353

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

   354

   355

        self.tempf = None 

   356

   357

        self.RegenSVGThread = None

   358

        self.RegenSVGLock = Lock()

   359

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

   360

        self.RegenSVGParams = None

   361

        self.Bind(wx.EVT_TIMER,

   362

                  self.RegenSVG,

   363

                  self.RegenSVGTimer)

   364

   365

        self.args_editors = []

   366

        self.paths_editors = []

   367

   368

    def SetMessage(self, msg):

   369

        self.staticmsg.SetLabel(msg)

   370

        self.main_sizer.Layout()

   371

   372

    def ResetSignature(self):

   373

        self.args_sizer.Clear()

   374

        for editor in self.args_editors:

   375

            editor.Destroy()

   376

        self.args_editors = []

   377

   378

        self.paths_sizer.Clear()

   379

        for editor in self.paths_editors:

   380

            editor.Destroy()

   381

        self.paths_editors = []

   382

   383

    def AddArgToSignature(self, arg, prefillarg):

   384

        new_editor = ArgEditor(self, arg, prefillarg)

   385

        self.args_editors.append(new_editor)

   386

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

   387

   388

    def AddPathToSignature(self, path):

   389

        new_editor = PathEditor(self, path)

   390

        self.paths_editors.append(new_editor)

   391

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

   392

   393

    def GotPathDnDOn(self, target_editor):

   394

        dndindex = self.paths_editors.index(target_editor)

   395

   396

        for hmitree_node,editor in zip(self.hmitree_nodes,

   397

                                   self.paths_editors[dndindex:]):

   398

            editor.SetPath(hmitree_node)

   399

   400

        self.RegenSVGNow()

   401

   402

    def RecallLibDir(self):

   403

        conf = self.Config.Read(_conf_key)

   404

        if len(conf) == 0:

   405

            return None

   406

        else:

   407

            return DecodeFileSystemPath(conf)

   408

   409

    def RememberLibDir(self, path):

   410

        self.Config.Write(_conf_key,

   411

                          EncodeFileSystemPath(path))

   412

        self.Config.Flush()

   413

   414

    def DrawPreview(self):

   415

        """

   416

        Refresh preview panel 

   417

        """

   418

        # Init preview panel paint device context

   419

        dc = wx.PaintDC(self.preview)

   420

        dc.Clear()

   421

   422

        if self.bmp:

   423

            # Get Preview panel size

   424

            sz = self.preview.GetClientSize()

   425

            w = self.bmp.GetWidth()

   426

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

   427

   428

   429

   430

    def OnSelectLibDir(self, event):

   431

        defaultpath = self.RecallLibDir()

   432

        if defaultpath == None:

   433

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

   434

   435

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

   436

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   437

   438

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

   439

            self.libdir = dialog.GetPath()

   440

            self.RememberLibDir(self.libdir)

   441

            self.widgetpicker.MakeTree(self.libdir)

   442

   443

        dialog.Destroy()

   444

   445

    def OnPaint(self, event):

   446

        """

   447

        Called when Preview panel needs to be redrawn

   448

        @param event: wx.PaintEvent

   449

        """

   450

        self.DrawPreview()

   451

        event.Skip()

   452

   453

    def GenThumbnail(self, svgpath, thumbpath):

   454

        inkpath = get_inkscape_path()

   455

        if inkpath is None:

   456

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

   457

            return False

   458

        # TODO: spawn a thread, to decouple thumbnail gen

   459

        status, result, _err_result = ProcessLogger(

   460

            None,

   461

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

   462

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

   463

        if status != 0:

   464

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

   465

            return False

   466

        return True

   467

   468

    def OnWidgetSelection(self, event):

   469

        """

   470

        Called when tree item is selected

   471

        @param event: wx.TreeEvent

   472

        """

   473

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

   474

        if item_pydata is not None:

   475

            svgpath = item_pydata

   476

            dname = os.path.dirname(svgpath)

   477

            fname = os.path.basename(svgpath)

   478

            hasher = hashlib.new('md5')

   479

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

   480

                while True:

   481

                    buf = afile.read(65536)

   482

                    if len(buf) > 0:

   483

                        hasher.update(buf)

   484

                    else:

   485

                        break

   486

            digest = hasher.hexdigest()

   487

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

   488

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