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

# 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 os.environ.has_key("SNAP"):

    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

                   map(lambda typename: 

   253

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

   254

                       accepts), 

   255

                   False)

   256

            if accepts and txt else None)

   257

        self.ParentObj.RegenSVGLater()

   258

        event.Skip()

   259

   260

class PathEditor(ParamEditor):

   261

    def __init__(self, parent, pathdesc):

   262

        ParamEditor.__init__(self, parent, pathdesc)

   263

        self.ParentObj = parent

   264

        self.pathdesc = pathdesc

   265

        DropTarget = PathDropTarget(self)

   266

        self.edit.SetDropTarget(DropTarget)

   267

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

   268

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

   269

   270

    def OnHMITreeDnD(self):

   271

        self.ParentObj.GotPathDnDOn(self)

   272

   273

    def SetPath(self, hmitree_node):

   274

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

   275

        self.setValidity(

   276

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

   277

   278

    def OnPathChanged(self, event):

   279

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

   280

        # Lazy way : hide validity

   281

        self.setValidity(None)

   282

        self.ParentObj.RegenSVGLater()

   283

        event.Skip()

   284

   285

def KeepDoubleNewLines(txt):

   286

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

   287

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

   288

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

   289

   290

_conf_key = "SVGHMIWidgetLib"

   291

_preview_height = 200

   292

_preview_margin = 5

   293

thumbnail_temp_path = None

   294

   295

class WidgetLibBrowser(wx.SplitterWindow):

   296

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

   297

                 size=wx.DefaultSize):

   298

   299

        wx.SplitterWindow.__init__(self, parent,

   300

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   301

   302

        self.bmp = None

   303

        self.msg = None

   304

        self.hmitree_nodes = []

   305

        self.selected_SVG = None

   306

        self.Controler = controler

   307

   308

        self.Config = wx.ConfigBase.Get()

   309

        self.libdir = self.RecallLibDir()

   310

        if self.libdir is None:

   311

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

   312

   313

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

   314

   315

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

   316

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

   317

        self.picker_sizer.AddGrowableCol(0)

   318

        self.picker_sizer.AddGrowableRow(1)

   319

   320

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

   321

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

   322

   323

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

   324

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

   325

        self.picker_sizer.Layout()

   326

        self.picker_panel.SetAutoLayout(True)

   327

        self.picker_panel.SetSizer(self.picker_sizer)

   328

   329

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

   330

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

   331

   332

   333

   334

        self.main_panel = ScrolledPanel(parent=self,

   335

                                                name='MiscellaneousPanel',

   336

                                                style=wx.TAB_TRAVERSAL)

   337

   338

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

   339

        self.main_sizer.AddGrowableCol(0)

   340

        self.main_sizer.AddGrowableRow(2)

   341

   342

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

   343

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

   344

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

   345

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

   346

                                     _("Widget's arguments"),

   347

                                     style = wx.ALIGN_CENTRE_HORIZONTAL)

   348

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

   349

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

   350

                                      _("Widget's variables"),

   351

                                      style = wx.ALIGN_CENTRE_HORIZONTAL)

   352

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

   353

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

   354

        self.signature_sizer.AddSpacer(5)

   355

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

   356

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

   357

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

   358

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

   359

        self.main_sizer.Layout()

   360

        self.main_panel.SetAutoLayout(True)

   361

        self.main_panel.SetSizer(self.main_sizer)

   362

        self.main_sizer.Fit(self.main_panel)

   363

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

   364

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

   365

   366

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

   367

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   368

   369

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

   370

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

   371

   372

        self.tempf = None 

   373

   374

        self.RegenSVGThread = None

   375

        self.RegenSVGLock = Lock()

   376

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

   377

        self.RegenSVGParams = None

   378

        self.Bind(wx.EVT_TIMER,

   379

                  self.RegenSVG,

   380

                  self.RegenSVGTimer)

   381

   382

        self.args_editors = []

   383

        self.paths_editors = []

   384

   385

    def SetMessage(self, msg):

   386

        self.staticmsg.SetLabel(msg)

   387

        self.main_sizer.Layout()

   388

   389

    def ResetSignature(self):

   390

        self.args_sizer.Clear()

   391

        for editor in self.args_editors:

   392

            editor.Destroy()

   393

        self.args_editors = []

   394

   395

        self.paths_sizer.Clear()

   396

        for editor in self.paths_editors:

   397

            editor.Destroy()

   398

        self.paths_editors = []

   399

   400

    def AddArgToSignature(self, arg, prefillarg):

   401

        new_editor = ArgEditor(self, arg, prefillarg)

   402

        self.args_editors.append(new_editor)

   403

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

   404

   405

    def AddPathToSignature(self, path):

   406

        new_editor = PathEditor(self, path)

   407

        self.paths_editors.append(new_editor)

   408

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

   409

   410

    def GotPathDnDOn(self, target_editor):

   411

        dndindex = self.paths_editors.index(target_editor)

   412

   413

        for hmitree_node,editor in zip(self.hmitree_nodes,

   414

                                   self.paths_editors[dndindex:]):

   415

            editor.SetPath(hmitree_node)

   416

   417

        self.RegenSVGNow()

   418

   419

    def RecallLibDir(self):

   420

        conf = self.Config.Read(_conf_key)

   421

        if len(conf) == 0:

   422

            return None

   423

        else:

   424

            return DecodeFileSystemPath(conf)

   425

   426

    def RememberLibDir(self, path):

   427

        self.Config.Write(_conf_key,

   428

                          EncodeFileSystemPath(path))

   429

        self.Config.Flush()

   430

   431

    def DrawPreview(self):

   432

        """

   433

        Refresh preview panel 

   434

        """

   435

        # Init preview panel paint device context

   436

        dc = wx.PaintDC(self.preview)

   437

        dc.Clear()

   438

   439

        if self.bmp:

   440

            # Get Preview panel size

   441

            sz = self.preview.GetClientSize()

   442

            w = self.bmp.GetWidth()

   443

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

   444

   445

   446

   447

    def OnSelectLibDir(self, event):

   448

        defaultpath = self.RecallLibDir()

   449

        if defaultpath == None:

   450

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

   451

   452

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

   453

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   454

   455

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

   456

            self.libdir = dialog.GetPath()

   457

            self.RememberLibDir(self.libdir)

   458

            self.widgetpicker.MakeTree(self.libdir)

   459

   460

        dialog.Destroy()

   461

   462

    def OnPaint(self, event):

   463

        """

   464

        Called when Preview panel needs to be redrawn

   465

        @param event: wx.PaintEvent

   466

        """

   467

        self.DrawPreview()

   468

        event.Skip()

   469

   470

    def GenThumbnail(self, svgpath, thumbpath):

   471

        inkpath = get_inkscape_path()

   472

        if inkpath is None:

   473

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

   474

            return False

   475

   476

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

   477

   478

        # TODO: spawn a thread, to decouple thumbnail gen

   479

        status, result, _err_result = ProcessLogger(

   480

            #self.Controler.GetCTRoot().logger,

   481

            None,

   482

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

   483

            export_opt + ' "' + thumbpath +

   484

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

   485

        if status != 0:

   486

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

   487

            return False