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

    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

    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

# When running as a confined Snap, /tmp isn't accessible from the outside

    35

# and Widget DnD to Inkscape can't work, since it can't find generated svg 

    36

# This forces tmp directory in $SNAP_USER_DATA, accessible from other apps

    37

if "SNAP" in os.environ:

    38

     NamedTemporaryFile_orig = NamedTemporaryFile

    39

     tmpdir = os.path.join(os.environ["SNAP_USER_DATA"], ".tmp")

    40

     if not os.path.exists(tmpdir):

    41

         os.mkdir(tmpdir)

    42

     def NamedTemporaryFile(*args,**kwargs):

    43

        kwargs["dir"] = tmpdir

    44

        return NamedTemporaryFile_orig(*args, **kwargs)

    45

    46

    47

ScriptDirectory = paths.AbsDir(__file__)

    48

    49

HMITreeDndMagicWord = "text/beremiz-hmitree"

    50

    51

class HMITreeSelector(wx.TreeCtrl):

    52

    def __init__(self, parent):

    53

    54

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

    55

            wx.TR_MULTIPLE |

    56

            wx.TR_HAS_BUTTONS |

    57

            wx.SUNKEN_BORDER |

    58

            wx.TR_LINES_AT_ROOT))

    59

    60

        self.ordered_items = []

    61

        self.parent = parent

    62

    63

        self.MakeTree()

    64

    65

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

    66

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

    67

    68

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    69

        for c in current_hmitree_root.children:

    70

            if hasattr(c, "children"):

    71

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

    72

                               if c.hmiclass is not None else c.name

    73

                tc_child = self.AppendItem(current_tc_root, display_name)

    74

                self.SetItemData(tc_child, c)

    75

    76

                self._recurseTree(c,tc_child)

    77

            else:

    78

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

    79

                tc_child = self.AppendItem(current_tc_root, display_name)

    80

                self.SetItemData(tc_child, c)

    81

    82

    def OnTreeNodeSelection(self, event):

    83

        items = self.GetSelections()

    84

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

    85

    86

        # append new items to ordered item list

    87

        for item_pydata in items_pydata:

    88

            if item_pydata not in self.ordered_items:

    89

                self.ordered_items.append(item_pydata)

    90

    91

        # filter out vanished items

    92

        self.ordered_items = [

    93

            item_pydata 

    94

            for item_pydata in self.ordered_items 

    95

            if item_pydata in items_pydata]

    96

    97

        self.parent.OnHMITreeNodeSelection(self.ordered_items)

    98

    99

    def OnTreeBeginDrag(self, event):

   100

        """

   101

        Called when a drag is started in tree

   102

        @param event: wx.TreeEvent

   103

        """

   104

        if self.ordered_items:

   105

            # Just send a recognizable mime-type, drop destination

   106

            # will get python data from parent

   107

            data = wx.CustomDataObject(HMITreeDndMagicWord)

   108

            dragSource = wx.DropSource(self)

   109

            dragSource.SetData(data)

   110

            dragSource.DoDragDrop()

   111

   112

    def MakeTree(self, hmi_tree_root=None):

   113

   114

        self.Freeze()

   115

   116

        self.root = None

   117

        self.DeleteAllItems()

   118

   119

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

   120

            if hmi_tree_root is None else "HMI"

   121

        self.root = self.AddRoot(root_display_name)

   122

        self.SetItemData(self.root, hmi_tree_root)

   123

   124

        if hmi_tree_root is not None:

   125

            self._recurseTree(hmi_tree_root, self.root)

   126

            self.Expand(self.root)

   127

   128

        self.Thaw()

   129

   130

class WidgetPicker(wx.TreeCtrl):

   131

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

   132

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

   133

            wx.TR_MULTIPLE |

   134

            wx.TR_HAS_BUTTONS |

   135

            wx.SUNKEN_BORDER |

   136

            wx.TR_LINES_AT_ROOT))

   137

   138

        self.MakeTree(initialdir)

   139

   140

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

   141

        """

   142

        recurse through subdirectories, but creates tree nodes 

   143

        only when (sub)directory conbtains .svg file

   144

        """

   145

        res = []

   146

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

   147

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

   148

            if os.path.isdir(p):

   149

   150

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

   151

                if len(r) > 0 :

   152

                    res = r

   153

                    dirlist = []

   154

                    current_tc_root = res.pop()

   155

   156

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

   157

                if len(dirlist) > 0 :

   158

                    res = []

   159

                    for d in dirlist:

   160

                        current_tc_root = self.AppendItem(current_tc_root, d)

   161

                        res.append(current_tc_root)

   162

                        self.SetItemData(current_tc_root, None)

   163

                    dirlist = []

   164

                    res.pop()

   165

                tc_child = self.AppendItem(current_tc_root, f)

   166

                self.SetItemData(tc_child, p)

   167

        return res

   168

   169

    def MakeTree(self, lib_dir = None):

   170

   171

        self.Freeze()

   172

   173

        self.root = None

   174

        self.DeleteAllItems()

   175

   176

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

   177

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

   178

        self.root = self.AddRoot(root_display_name)

   179

        self.SetItemData(self.root, None)

   180

   181

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

   182

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

   183

            self.Expand(self.root)

   184

   185

        self.Thaw()

   186

   187

class PathDropTarget(wx.DropTarget):

   188

   189

    def __init__(self, parent):

   190

        data = wx.CustomDataObject(HMITreeDndMagicWord)

   191

        wx.DropTarget.__init__(self, data)

   192

        self.ParentWindow = parent

   193

   194

    def OnDrop(self, x, y):

   195

        self.ParentWindow.OnHMITreeDnD()

   196

        return True

   197

   198

class ParamEditor(wx.Panel):

   199

    def __init__(self, parent, paramdesc):

   200

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

   201

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

   202

        if paramdesc.text:

   203

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

   204

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

   205

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

   206

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

   207

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

   208

        self.edit = wx.TextCtrl(self)

   209

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

   210

        self.edit_sizer.AddGrowableCol(0)

   211

        self.edit_sizer.AddGrowableRow(0)

   212

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

   213

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

   214

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

   215

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

   216

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

   217

        self.SetSizer(self.main_sizer)

   218

        self.main_sizer.Fit(self)

   219

   220

    def GetValue(self):

   221

        return self.edit.GetValue()

   222

   223

    def setValidity(self, validity):

   224

        if validity is not None:

   225

            bmp = self.valid_bmp if validity else self.invalid_bmp

   226

            self.validity_sbmp.SetBitmap(bmp)

   227

            self.validity_sbmp.Show(True)

   228

        else :

   229

            self.validity_sbmp.Show(False)

   230

   231

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

   232

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

   233

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

   234

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

   235

   236

class ArgEditor(ParamEditor):

   237

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

   238

        ParamEditor.__init__(self, parent, argdesc)

   239

        self.ParentObj = parent

   240

        self.argdesc = argdesc

   241

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

   242

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

   243

        self.edit.SetValue(prefill)

   244

        # TODO add a button to add more ArgEditror instance 

   245

        #      when ordinality is multiple

   246

   247

    def OnArgChanged(self, event):

   248

        txt = self.edit.GetValue()

   249

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

   250

        self.setValidity(

   251

            reduce(or_,

   252

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

   253

                   False)

   254

            if accepts and txt else None)

   255

        self.ParentObj.RegenSVGLater()

   256

        event.Skip()

   257

   258

class PathEditor(ParamEditor):

   259

    def __init__(self, parent, pathdesc):

   260

        ParamEditor.__init__(self, parent, pathdesc)

   261

        self.ParentObj = parent

   262

        self.pathdesc = pathdesc

   263

        DropTarget = PathDropTarget(self)

   264

        self.edit.SetDropTarget(DropTarget)

   265

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

   266

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

   267

   268

    def OnHMITreeDnD(self):

   269

        self.ParentObj.GotPathDnDOn(self)

   270

   271

    def SetPath(self, hmitree_node):

   272

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

   273

        self.setValidity(

   274

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

   275

   276

    def OnPathChanged(self, event):

   277

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

   278

        # Lazy way : hide validity

   279

        self.setValidity(None)

   280

        self.ParentObj.RegenSVGLater()

   281

        event.Skip()

   282

   283

def KeepDoubleNewLines(txt):

   284

    return "\n\n".join([re.sub(r'\s+',' ',s) for s in txt.split("\n\n")])

   285

   286

_conf_key = "SVGHMIWidgetLib"

   287

_preview_height = 200

   288

_preview_margin = 5

   289

thumbnail_temp_path = None

   290

   291

class WidgetLibBrowser(wx.SplitterWindow):

   292

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

   293

                 size=wx.DefaultSize):

   294

   295

        wx.SplitterWindow.__init__(self, parent,

   296

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   297

   298

        self.bmp = None

   299

        self.msg = None

   300

        self.hmitree_nodes = []

   301

        self.selected_SVG = None

   302

        self.Controler = controler

   303

   304

        self.Config = wx.ConfigBase.Get()

   305

        self.libdir = self.RecallLibDir()

   306

        if self.libdir is None:

   307

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

   308

   309

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

   310

   311

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

   312

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

   313

        self.picker_sizer.AddGrowableCol(0)

   314

        self.picker_sizer.AddGrowableRow(1)

   315

   316

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

   317

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

   318

   319

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

   320

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

   321

        self.picker_sizer.Layout()

   322

        self.picker_panel.SetAutoLayout(True)

   323

        self.picker_panel.SetSizer(self.picker_sizer)

   324

   325

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

   326

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

   327

   328

   329

   330

        self.main_panel = ScrolledPanel(parent=self,

   331

                                                name='MiscellaneousPanel',

   332

                                                style=wx.TAB_TRAVERSAL)

   333

   334

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

   335

        self.main_sizer.AddGrowableCol(0)

   336

        self.main_sizer.AddGrowableRow(2)

   337

   338

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

   339

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

   340

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

   341

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

   342

                                     _("Widget's arguments"),

   343

                                     style = wx.ALIGN_CENTRE_HORIZONTAL)

   344

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

   345

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

   346

                                      _("Widget's variables"),

   347

                                      style = wx.ALIGN_CENTRE_HORIZONTAL)

   348

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

   349

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

   350

        self.signature_sizer.AddSpacer(5)

   351

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

   352

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

   353

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

   354

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

   355

        self.main_sizer.Layout()

   356

        self.main_panel.SetAutoLayout(True)

   357

        self.main_panel.SetSizer(self.main_sizer)

   358

        self.main_sizer.Fit(self.main_panel)

   359

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

   360

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

   361

   362

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

   363

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   364

   365

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

   366

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

   367

   368

        self.tempf = None 

   369

   370

        self.RegenSVGThread = None

   371

        self.RegenSVGLock = Lock()

   372

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

   373

        self.RegenSVGParams = None

   374

        self.Bind(wx.EVT_TIMER,

   375

                  self.RegenSVG,

   376

                  self.RegenSVGTimer)

   377

   378

        self.args_editors = []

   379

        self.paths_editors = []

   380

   381

    def SetMessage(self, msg):

   382

        self.staticmsg.SetLabel(msg)

   383

        self.main_sizer.Layout()

   384

   385

    def ResetSignature(self):

   386

        self.args_sizer.Clear()

   387

        for editor in self.args_editors:

   388

            editor.Destroy()

   389

        self.args_editors = []

   390

   391

        self.paths_sizer.Clear()

   392

        for editor in self.paths_editors:

   393

            editor.Destroy()

   394

        self.paths_editors = []

   395

   396

    def AddArgToSignature(self, arg, prefillarg):

   397

        new_editor = ArgEditor(self, arg, prefillarg)

   398

        self.args_editors.append(new_editor)

   399

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

   400

   401

    def AddPathToSignature(self, path):

   402

        new_editor = PathEditor(self, path)

   403

        self.paths_editors.append(new_editor)

   404

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

   405

   406

    def GotPathDnDOn(self, target_editor):

   407

        dndindex = self.paths_editors.index(target_editor)

   408

   409

        for hmitree_node,editor in zip(self.hmitree_nodes,

   410

                                   self.paths_editors[dndindex:]):

   411

            editor.SetPath(hmitree_node)

   412

   413

        self.RegenSVGNow()

   414

   415

    def RecallLibDir(self):

   416

        conf = self.Config.Read(_conf_key)

   417

        if len(conf) == 0:

   418

            return None

   419

        else:

   420

            return DecodeFileSystemPath(conf)

   421

   422

    def RememberLibDir(self, path):

   423

        self.Config.Write(_conf_key,

   424

                          EncodeFileSystemPath(path))

   425

        self.Config.Flush()

   426

   427

    def DrawPreview(self):

   428

        """

   429

        Refresh preview panel 

   430

        """

   431

        # Init preview panel paint device context

   432

        dc = wx.PaintDC(self.preview)

   433

        dc.Clear()

   434

   435

        if self.bmp:

   436

            # Get Preview panel size

   437

            sz = self.preview.GetClientSize()

   438

            w = self.bmp.GetWidth()

   439

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

   440

   441

   442

   443

    def OnSelectLibDir(self, event):

   444

        defaultpath = self.RecallLibDir()

   445

        if defaultpath == None:

   446

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

   447

   448

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

   449

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   450

   451

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

   452

            self.libdir = dialog.GetPath()

   453

            self.RememberLibDir(self.libdir)

   454

            self.widgetpicker.MakeTree(self.libdir)

   455

   456

        dialog.Destroy()

   457

   458

    def OnPaint(self, event):

   459

        """

   460

        Called when Preview panel needs to be redrawn

   461

        @param event: wx.PaintEvent

   462

        """

   463

        self.DrawPreview()

   464

        event.Skip()

   465

   466

    def GenThumbnail(self, svgpath, thumbpath):

   467

        inkpath = get_inkscape_path()

   468

        if inkpath is None:

   469

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

   470

            return False

   471

   472

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

   473

   474

        # TODO: spawn a thread, to decouple thumbnail gen

   475

        status, result, _err_result = ProcessLogger(

   476

            #self.Controler.GetCTRoot().logger,

   477

            None,

   478

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

   479

            export_opt + ' "' + thumbpath +

   480

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

   481

        if status != 0:

   482

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

   483

            return False

   484

        return True

   485

   486

    def OnWidgetSelection(self, event):

   487

        """