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

import tempfile

    15

from threading import Thread, Lock

    16

from functools import reduce

    17

from itertools import izip

    18

from operator import or_

    19

from tempfile import NamedTemporaryFile

    20

    21

import wx

    22

from wx.lib.scrolledpanel import ScrolledPanel

    23

    24

from lxml import etree

    25

from lxml.etree import XSLTApplyError

    26

from XSLTransform import XSLTransform

    27

    28

import util.paths as paths

    29

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    30

from docutil import get_inkscape_path, get_inkscape_version

    31

    32

from util.ProcessLogger import ProcessLogger

    33

    34

ScriptDirectory = paths.AbsDir(__file__)

    35

    36

HMITreeDndMagicWord = "text/beremiz-hmitree"

    37

    38

class HMITreeSelector(wx.TreeCtrl):

    39

    def __init__(self, parent):

    40

    41

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

    42

            wx.TR_MULTIPLE |

    43

            wx.TR_HAS_BUTTONS |

    44

            wx.SUNKEN_BORDER |

    45

            wx.TR_LINES_AT_ROOT))

    46

    47

        self.ordered_items = []

    48

        self.parent = parent

    49

    50

        self.MakeTree()

    51

    52

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

    53

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

    54

    55

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    56

        for c in current_hmitree_root.children:

    57

            if hasattr(c, "children"):

    58

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

    59

                               if c.hmiclass is not None else c.name

    60

                tc_child = self.AppendItem(current_tc_root, display_name)

    61

                self.SetPyData(tc_child, c)

    62

    63

                self._recurseTree(c,tc_child)

    64

            else:

    65

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

    66

                tc_child = self.AppendItem(current_tc_root, display_name)

    67

                self.SetPyData(tc_child, c)

    68

    69

    def OnTreeNodeSelection(self, event):

    70

        items = self.GetSelections()

    71

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

    72

    73

        # append new items to ordered item list

    74

        for item_pydata in items_pydata:

    75

            if item_pydata not in self.ordered_items:

    76

                self.ordered_items.append(item_pydata)

    77

    78

        # filter out vanished items

    79

        self.ordered_items = [

    80

            item_pydata 

    81

            for item_pydata in self.ordered_items 

    82

            if item_pydata in items_pydata]

    83

    84

        self.parent.OnHMITreeNodeSelection(self.ordered_items)

    85

    86

    def OnTreeBeginDrag(self, event):

    87

        """

    88

        Called when a drag is started in tree

    89

        @param event: wx.TreeEvent

    90

        """

    91

        if self.ordered_items:

    92

            # Just send a recognizable mime-type, drop destination

    93

            # will get python data from parent

    94

            data = wx.CustomDataObject(HMITreeDndMagicWord)

    95

            dragSource = wx.DropSource(self)

    96

            dragSource.SetData(data)

    97

            dragSource.DoDragDrop()

    98

    99

    def MakeTree(self, hmi_tree_root=None):

   100

   101

        self.Freeze()

   102

   103

        self.root = None

   104

        self.DeleteAllItems()

   105

   106

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

   107

            if hmi_tree_root is None else "HMI"

   108

        self.root = self.AddRoot(root_display_name)

   109

        self.SetPyData(self.root, hmi_tree_root)

   110

   111

        if hmi_tree_root is not None:

   112

            self._recurseTree(hmi_tree_root, self.root)

   113

            self.Expand(self.root)

   114

   115

        self.Thaw()

   116

   117

class WidgetPicker(wx.TreeCtrl):

   118

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

   119

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

   120

            wx.TR_MULTIPLE |

   121

            wx.TR_HAS_BUTTONS |

   122

            wx.SUNKEN_BORDER |

   123

            wx.TR_LINES_AT_ROOT))

   124

   125

        self.MakeTree(initialdir)

   126

   127

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

   128

        """

   129

        recurse through subdirectories, but creates tree nodes 

   130

        only when (sub)directory conbtains .svg file

   131

        """

   132

        res = []

   133

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

   134

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

   135

            if os.path.isdir(p):

   136

   137

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

   138

                if len(r) > 0 :

   139

                    res = r

   140

                    dirlist = []

   141

                    current_tc_root = res.pop()

   142

   143

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

   144

                if len(dirlist) > 0 :

   145

                    res = []

   146

                    for d in dirlist:

   147

                        current_tc_root = self.AppendItem(current_tc_root, d)

   148

                        res.append(current_tc_root)

   149

                        self.SetPyData(current_tc_root, None)

   150

                    dirlist = []

   151

                    res.pop()

   152

                tc_child = self.AppendItem(current_tc_root, f)

   153

                self.SetPyData(tc_child, p)

   154

        return res

   155

   156

    def MakeTree(self, lib_dir = None):

   157

   158

        self.Freeze()

   159

   160

        self.root = None

   161

        self.DeleteAllItems()

   162

   163

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

   164

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

   165

        self.root = self.AddRoot(root_display_name)

   166

        self.SetPyData(self.root, None)

   167

   168

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

   169

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

   170

            self.Expand(self.root)

   171

   172

        self.Thaw()

   173

   174

class PathDropTarget(wx.DropTarget):

   175

   176

    def __init__(self, parent):

   177

        data = wx.CustomDataObject(HMITreeDndMagicWord)

   178

        wx.DropTarget.__init__(self, data)

   179

        self.ParentWindow = parent

   180

   181

    def OnDrop(self, x, y):

   182

        self.ParentWindow.OnHMITreeDnD()

   183

        return True

   184

   185

class ParamEditor(wx.Panel):

   186

    def __init__(self, parent, paramdesc):

   187

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

   188

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

   189

        if paramdesc.text:

   190

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

   191

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

   192

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

   193

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

   194

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

   195

        self.edit = wx.TextCtrl(self)

   196

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

   197

        self.edit_sizer.AddGrowableCol(0)

   198

        self.edit_sizer.AddGrowableRow(0)

   199

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

   200

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

   201

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

   202

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

   203

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

   204

        self.SetSizer(self.main_sizer)

   205

        self.main_sizer.Fit(self)

   206

   207

    def GetValue(self):

   208

        return self.edit.GetValue()

   209

   210

    def setValidity(self, validity):

   211

        if validity is not None:

   212

            bmp = self.valid_bmp if validity else self.invalid_bmp

   213

            self.validity_sbmp.SetBitmap(bmp)

   214

            self.validity_sbmp.Show(True)

   215

        else :

   216

            self.validity_sbmp.Show(False)

   217

   218

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

   219

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

   220

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

   221

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

   222

   223

class ArgEditor(ParamEditor):

   224

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

   225

        ParamEditor.__init__(self, parent, argdesc)

   226

        self.ParentObj = parent

   227

        self.argdesc = argdesc

   228

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

   229

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

   230

        self.edit.SetValue(prefill)

   231

        # TODO add a button to add more ArgEditror instance 

   232

        #      when ordinality is multiple

   233

   234

    def OnArgChanged(self, event):

   235

        txt = self.edit.GetValue()

   236

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

   237

        self.setValidity(

   238

            reduce(or_,

   239

                   map(lambda typename: 

   240

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

   241

                       accepts), 

   242

                   False)

   243

            if accepts and txt else None)

   244

        self.ParentObj.RegenSVGLater()

   245

        event.Skip()

   246

   247

class PathEditor(ParamEditor):

   248

    def __init__(self, parent, pathdesc):

   249

        ParamEditor.__init__(self, parent, pathdesc)

   250

        self.ParentObj = parent

   251

        self.pathdesc = pathdesc

   252

        DropTarget = PathDropTarget(self)

   253

        self.edit.SetDropTarget(DropTarget)

   254

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

   255

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

   256

   257

    def OnHMITreeDnD(self):

   258

        self.ParentObj.GotPathDnDOn(self)

   259

   260

    def SetPath(self, hmitree_node):

   261

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

   262

        self.setValidity(

   263

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

   264

   265

    def OnPathChanged(self, event):

   266

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

   267

        # Lazy way : hide validity

   268

        self.setValidity(None)

   269

        self.ParentObj.RegenSVGLater()

   270

        event.Skip()

   271

   272

def KeepDoubleNewLines(txt):

   273

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

   274

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

   275

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

   276

   277

_conf_key = "SVGHMIWidgetLib"

   278

_preview_height = 200

   279

_preview_margin = 5

   280

thumbnail_temp_path = None

   281

   282

class WidgetLibBrowser(wx.SplitterWindow):

   283

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

   284

                 size=wx.DefaultSize):

   285

   286

        wx.SplitterWindow.__init__(self, parent,

   287

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   288

   289

        self.bmp = None

   290

        self.msg = None

   291

        self.hmitree_nodes = []

   292

        self.selected_SVG = None

   293

        self.Controler = controler

   294

   295

        self.Config = wx.ConfigBase.Get()

   296

        self.libdir = self.RecallLibDir()

   297

        if self.libdir is None:

   298

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

   299

   300

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

   301

   302

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

   303

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

   304

        self.picker_sizer.AddGrowableCol(0)

   305

        self.picker_sizer.AddGrowableRow(1)

   306

   307

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

   308

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

   309

   310

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

   311

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

   312

        self.picker_sizer.Layout()

   313

        self.picker_panel.SetAutoLayout(True)

   314

        self.picker_panel.SetSizer(self.picker_sizer)

   315

   316

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

   317

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

   318

   319

   320

   321

        self.main_panel = ScrolledPanel(parent=self,

   322

                                                name='MiscellaneousPanel',

   323

                                                style=wx.TAB_TRAVERSAL)

   324

   325

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

   326

        self.main_sizer.AddGrowableCol(0)

   327

        self.main_sizer.AddGrowableRow(2)

   328

   329

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

   330

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

   331

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

   332

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

   333

                                     _("Widget's arguments"),

   334

                                     style = wx.ALIGN_CENTRE_HORIZONTAL)

   335

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

   336

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

   337

                                      _("Widget's variables"),

   338

                                      style = wx.ALIGN_CENTRE_HORIZONTAL)

   339

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

   340

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

   341

        self.signature_sizer.AddSpacer(5)

   342

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

   343

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

   344

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

   345

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

   346

        self.main_sizer.Layout()

   347

        self.main_panel.SetAutoLayout(True)

   348

        self.main_panel.SetSizer(self.main_sizer)

   349

        self.main_sizer.Fit(self.main_panel)

   350

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

   351

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

   352

   353

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

   354

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   355

   356

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

   357

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

   358

   359

        self.tempf = None 

   360

   361

        self.RegenSVGThread = None

   362

        self.RegenSVGLock = Lock()

   363

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

   364

        self.RegenSVGParams = None

   365

        self.Bind(wx.EVT_TIMER,

   366

                  self.RegenSVG,

   367

                  self.RegenSVGTimer)

   368

   369

        self.args_editors = []

   370

        self.paths_editors = []

   371

   372

    def SetMessage(self, msg):

   373

        self.staticmsg.SetLabel(msg)

   374

        self.main_sizer.Layout()

   375

   376

    def ResetSignature(self):

   377

        self.args_sizer.Clear()

   378

        for editor in self.args_editors:

   379

            editor.Destroy()

   380

        self.args_editors = []

   381

   382

        self.paths_sizer.Clear()

   383

        for editor in self.paths_editors:

   384

            editor.Destroy()

   385

        self.paths_editors = []

   386

   387

    def AddArgToSignature(self, arg, prefillarg):

   388

        new_editor = ArgEditor(self, arg, prefillarg)

   389

        self.args_editors.append(new_editor)

   390

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

   391

   392

    def AddPathToSignature(self, path):

   393

        new_editor = PathEditor(self, path)

   394

        self.paths_editors.append(new_editor)

   395

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

   396

   397

    def GotPathDnDOn(self, target_editor):

   398

        dndindex = self.paths_editors.index(target_editor)

   399

   400

        for hmitree_node,editor in zip(self.hmitree_nodes,

   401

                                   self.paths_editors[dndindex:]):

   402

            editor.SetPath(hmitree_node)

   403

   404

        self.RegenSVGNow()

   405

   406

    def RecallLibDir(self):

   407

        conf = self.Config.Read(_conf_key)

   408

        if len(conf) == 0:

   409

            return None

   410

        else:

   411

            return DecodeFileSystemPath(conf)

   412

   413

    def RememberLibDir(self, path):

   414

        self.Config.Write(_conf_key,

   415

                          EncodeFileSystemPath(path))

   416

        self.Config.Flush()

   417

   418

    def DrawPreview(self):

   419

        """

   420

        Refresh preview panel 

   421

        """

   422

        # Init preview panel paint device context

   423

        dc = wx.PaintDC(self.preview)

   424

        dc.Clear()

   425

   426

        if self.bmp:

   427

            # Get Preview panel size

   428

            sz = self.preview.GetClientSize()

   429

            w = self.bmp.GetWidth()

   430

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

   431

   432

   433

   434

    def OnSelectLibDir(self, event):

   435

        defaultpath = self.RecallLibDir()

   436

        if defaultpath == None:

   437

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

   438

   439

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

   440

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   441

   442

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

   443

            self.libdir = dialog.GetPath()

   444

            self.RememberLibDir(self.libdir)

   445

            self.widgetpicker.MakeTree(self.libdir)

   446

   447

        dialog.Destroy()

   448

   449

    def OnPaint(self, event):

   450

        """

   451

        Called when Preview panel needs to be redrawn

   452

        @param event: wx.PaintEvent

   453

        """

   454

        self.DrawPreview()

   455

        event.Skip()

   456

   457

    def GenThumbnail(self, svgpath, thumbpath):

   458

        inkpath = get_inkscape_path()

   459

        if inkpath is None:

   460

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

   461

            return False

   462

   463

        export_opt = "-o" if get_inkscape_version()[0] > 0 else "-e"

   464

   465

        # TODO: spawn a thread, to decouple thumbnail gen

   466

        status, result, _err_result = ProcessLogger(

   467

            self.Controler.GetCTRoot().logger,

   468

            '"' + inkpath + '" "' + svgpath + '" ' +

   469

            export_opt + ' "' + thumbpath +

   470

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

   471

        if status != 0:

   472

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

   473

            return False

   474

        return True

   475

   476

    def OnWidgetSelection(self, event):

   477

        """

   478

        Called when tree item is selected

   479

        @param event: wx.TreeEvent

   480

        """

   481

        global thumbnail_temp_path

   482

        event.Skip()

   483

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

   484

        if item_pydata is not None:

   485

            svgpath = item_pydata

   486

   487

            if thumbnail_temp_path is None:

   488

                try: