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 functools import reduce

    15

from operator import or_

    16

from tempfile import NamedTemporaryFile

    17

    18

import wx

    19

from wx.lib.scrolledpanel import ScrolledPanel

    20

    21

from lxml import etree

    22

from lxml.etree import XSLTApplyError

    23

from XSLTransform import XSLTransform

    24

    25

import util.paths as paths

    26

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    27

from docutil import get_inkscape_path

    28

    29

from util.ProcessLogger import ProcessLogger

    30

    31

ScriptDirectory = paths.AbsDir(__file__)

    32

    33

HMITreeDndMagicWord = "text/beremiz-hmitree"

    34

    35

class HMITreeSelector(wx.TreeCtrl):

    36

    def __init__(self, parent):

    37

    38

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

    39

            wx.TR_MULTIPLE |

    40

            wx.TR_HAS_BUTTONS |

    41

            wx.SUNKEN_BORDER |

    42

            wx.TR_LINES_AT_ROOT))

    43

    44

        self.ordered_items = []

    45

        self.parent = parent

    46

    47

        self.MakeTree()

    48

    49

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

    50

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

    51

    52

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    53

        for c in current_hmitree_root.children:

    54

            if hasattr(c, "children"):

    55

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

    56

                               if c.hmiclass is not None else c.name

    57

                tc_child = self.AppendItem(current_tc_root, display_name)

    58

                self.SetPyData(tc_child, c)

    59

    60

                self._recurseTree(c,tc_child)

    61

            else:

    62

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

    63

                tc_child = self.AppendItem(current_tc_root, display_name)

    64

                self.SetPyData(tc_child, c)

    65

    66

    def OnTreeNodeSelection(self, event):

    67

        items = self.GetSelections()

    68

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

    69

    70

        # append new items to ordered item list

    71

        for item_pydata in items_pydata:

    72

            if item_pydata not in self.ordered_items:

    73

                self.ordered_items.append(item_pydata)

    74

    75

        # filter out vanished items

    76

        self.ordered_items = [

    77

            item_pydata 

    78

            for item_pydata in self.ordered_items 

    79

            if item_pydata in items_pydata]

    80

    81

        self.parent.OnHMITreeNodeSelection(self.ordered_items)

    82

    83

    def OnTreeBeginDrag(self, event):

    84

        """

    85

        Called when a drag is started in tree

    86

        @param event: wx.TreeEvent

    87

        """

    88

        if self.ordered_items:

    89

            print("boink")

    90

            # Just send a recognizable mime-type, drop destination

    91

            # will get python data from parent

    92

            data = wx.CustomDataObject(HMITreeDndMagicWord)

    93

            dragSource = wx.DropSource(self)

    94

            dragSource.SetData(data)

    95

            dragSource.DoDragDrop()

    96

    97

    def MakeTree(self, hmi_tree_root=None):

    98

    99

        self.Freeze()

   100

   101

        self.root = None

   102

        self.DeleteAllItems()

   103

   104

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

   105

            if hmi_tree_root is None else "HMI"

   106

        self.root = self.AddRoot(root_display_name)

   107

        self.SetPyData(self.root, hmi_tree_root)

   108

   109

        if hmi_tree_root is not None:

   110

            self._recurseTree(hmi_tree_root, self.root)

   111

            self.Expand(self.root)

   112

   113

        self.Thaw()

   114

   115

class WidgetPicker(wx.TreeCtrl):

   116

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

   117

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

   118

            wx.TR_MULTIPLE |

   119

            wx.TR_HAS_BUTTONS |

   120

            wx.SUNKEN_BORDER |

   121

            wx.TR_LINES_AT_ROOT))

   122

   123

        self.MakeTree(initialdir)

   124

   125

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

   126

        """

   127

        recurse through subdirectories, but creates tree nodes 

   128

        only when (sub)directory conbtains .svg file

   129

        """

   130

        res = []

   131

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

   132

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

   133

            if os.path.isdir(p):

   134

   135

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

   136

                if len(r) > 0 :

   137

                    res = r

   138

                    dirlist = []

   139

                    current_tc_root = res.pop()

   140

   141

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

   142

                if len(dirlist) > 0 :

   143

                    res = []

   144

                    for d in dirlist:

   145

                        current_tc_root = self.AppendItem(current_tc_root, d)

   146

                        res.append(current_tc_root)

   147

                        self.SetPyData(current_tc_root, None)

   148

                    dirlist = []

   149

                    res.pop()

   150

                tc_child = self.AppendItem(current_tc_root, f)

   151

                self.SetPyData(tc_child, p)

   152

        return res

   153

   154

    def MakeTree(self, lib_dir = None):

   155

   156

        self.Freeze()

   157

   158

        self.root = None

   159

        self.DeleteAllItems()

   160

   161

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

   162

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

   163

        self.root = self.AddRoot(root_display_name)

   164

        self.SetPyData(self.root, None)

   165

   166

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

   167

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

   168

            self.Expand(self.root)

   169

   170

        self.Thaw()

   171

   172

class PathDropTarget(wx.DropTarget):

   173

   174

    def __init__(self, parent):

   175

        data = wx.CustomDataObject(HMITreeDndMagicWord)

   176

        wx.DropTarget.__init__(self, data)

   177

        self.ParentWindow = parent

   178

   179

    def OnDrop(self, x, y):

   180

        self.ParentWindow.OnHMITreeDnD()

   181

        return True

   182

   183

class ParamEditor(wx.Panel):

   184

    def __init__(self, parent, paramdesc):

   185

   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 setValidity(self, validity):

   207

        if validity is not None:

   208

            bmp = self.valid_bmp if validity else self.invalid_bmp

   209

            self.validity_sbmp.SetBitmap(bmp)

   210

            self.validity_sbmp.Show(True)

   211

        else :

   212

            self.validity_sbmp.Show(False)

   213

   214

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

   215

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

   216

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

   217

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

   218

   219

class ArgEditor(ParamEditor):

   220

    def __init__(self, parent, argdesc):

   221

        ParamEditor.__init__(self, parent, argdesc)

   222

        self.ParentObj = parent

   223

        self.argdesc = argdesc

   224

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

   225

   226

    def OnArgChanged(self, event):

   227

        txt = self.edit.GetValue()

   228

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

   229

        self.setValidity(

   230

            reduce(or_,

   231

                   map(lambda typename: 

   232

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

   233

                       accepts), 

   234

                   False)

   235

            if accepts and txt else None)

   236

        event.Skip()

   237

   238

class PathEditor(ParamEditor):

   239

    def __init__(self, parent, pathdesc):

   240

        ParamEditor.__init__(self, parent, pathdesc)

   241

        self.ParentObj = parent

   242

        self.pathdesc = pathdesc

   243

        DropTarget = PathDropTarget(self)

   244

        self.edit.SetDropTarget(DropTarget)

   245

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

   246

   247

    def OnHMITreeDnD(self):

   248

        self.ParentObj.GotPathDnDOn(self)

   249

   250

    def SetPath(self, hmitree_node):

   251

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

   252

        self.setValidity(

   253

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

   254

   255

    def OnPathChanged(self, event):

   256

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

   257

        # Lazy way : hide validity

   258

        self.setValidity(None)

   259

        event.Skip()

   260

   261

   262

_conf_key = "SVGHMIWidgetLib"

   263

_preview_height = 200

   264

_preview_margin = 5

   265

class WidgetLibBrowser(wx.SplitterWindow):

   266

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

   267

                 size=wx.DefaultSize):

   268

   269

        wx.SplitterWindow.__init__(self, parent,

   270

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   271

   272

        self.bmp = None

   273

        self.msg = None

   274

        self.hmitree_nodes = []

   275

        self.selected_SVG = None

   276

   277

        self.Config = wx.ConfigBase.Get()

   278

        self.libdir = self.RecallLibDir()

   279

   280

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

   281

   282

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

   283

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

   284

        self.picker_sizer.AddGrowableCol(0)

   285

        self.picker_sizer.AddGrowableRow(1)

   286

   287

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

   288

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

   289

   290

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

   291

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

   292

        self.picker_sizer.Layout()

   293

        self.picker_panel.SetAutoLayout(True)

   294

        self.picker_panel.SetSizer(self.picker_sizer)

   295

   296

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

   297

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

   298

   299

   300

   301

        self.main_panel = ScrolledPanel(parent=self,

   302

                                                name='MiscellaneousPanel',

   303

                                                style=wx.TAB_TRAVERSAL)

   304

   305

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

   306

        self.main_sizer.AddGrowableCol(0)

   307

        self.main_sizer.AddGrowableRow(2)

   308

   309

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

   310

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

   311

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

   312

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

   313

                                     _("Widget's arguments"),

   314

                                     style = wx.ALIGN_RIGHT)

   315

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

   316

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

   317

                                      _("Widget's variables"),

   318

                                      style = wx.ALIGN_RIGHT)

   319

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

   320

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

   321

        self.signature_sizer.AddSpacer(5)

   322

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

   323

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

   324

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

   325

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

   326

        self.main_sizer.Layout()

   327

        self.main_panel.SetAutoLayout(True)

   328

        self.main_panel.SetSizer(self.main_sizer)

   329

        self.main_sizer.Fit(self.main_panel)

   330

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

   331

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

   332

   333

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

   334

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   335

   336

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

   337

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

   338

   339

        self.tempf = None 

   340

   341

        self.args_editors = []

   342

        self.paths_editors = []

   343

   344

    def ResetSignature(self):

   345

        self.args_sizer.Clear()

   346

        for editor in self.args_editors:

   347

            editor.Destroy()

   348

        self.args_editors = []

   349

   350

        self.paths_sizer.Clear()

   351

        for editor in self.paths_editors:

   352

            editor.Destroy()

   353

        self.paths_editors = []

   354

   355

    def AddArgToSignature(self, arg):

   356

        new_editor = ArgEditor(self, arg)

   357

        self.args_editors.append(new_editor)

   358

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

   359

   360

    def AddPathToSignature(self, path):

   361

        new_editor = PathEditor(self, path)

   362

        self.paths_editors.append(new_editor)

   363

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

   364

   365

    def GotPathDnDOn(self, target_editor):

   366

        dndindex = self.paths_editors.index(target_editor)

   367

   368

        for hmitree_node,editor in zip(self.hmitree_nodes,

   369

                                   self.paths_editors[dndindex:]):

   370

            editor.SetPath(hmitree_node)

   371

   372

    def RecallLibDir(self):

   373

        conf = self.Config.Read(_conf_key)

   374

        if len(conf) == 0:

   375

            return None

   376

        else:

   377

            return DecodeFileSystemPath(conf)

   378

   379

    def RememberLibDir(self, path):

   380

        self.Config.Write(_conf_key,

   381

                          EncodeFileSystemPath(path))

   382

        self.Config.Flush()

   383

   384

    def DrawPreview(self):

   385

        """

   386

        Refresh preview panel 

   387

        """

   388

        # Init preview panel paint device context

   389

        dc = wx.PaintDC(self.preview)

   390

        dc.Clear()

   391

   392

        if self.bmp:

   393

            # Get Preview panel size

   394

            sz = self.preview.GetClientSize()

   395

            w = self.bmp.GetWidth()

   396

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

   397

   398

   399

   400

    def OnSelectLibDir(self, event):

   401

        defaultpath = self.RecallLibDir()

   402

        if defaultpath == None:

   403

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

   404

   405

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

   406

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   407

   408

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

   409

            self.libdir = dialog.GetPath()

   410

            self.RememberLibDir(self.libdir)

   411

            self.widgetpicker.MakeTree(self.libdir)

   412

   413

        dialog.Destroy()

   414

   415

    def OnPaint(self, event):

   416

        """

   417

        Called when Preview panel needs to be redrawn

   418

        @param event: wx.PaintEvent

   419

        """

   420

        self.DrawPreview()

   421

        event.Skip()

   422

   423

    def GenThumbnail(self, svgpath, thumbpath):

   424

        inkpath = get_inkscape_path()

   425

        if inkpath is None:

   426

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

   427

            return False

   428

        # TODO: spawn a thread, to decouple thumbnail gen

   429

        status, result, _err_result = ProcessLogger(

   430

            None,

   431

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

   432

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

   433

        if status != 0:

   434

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

   435

            return False

   436

        return True

   437

   438

    def OnWidgetSelection(self, event):

   439

        """

   440

        Called when tree item is selected

   441

        @param event: wx.TreeEvent

   442

        """

   443

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

   444

        if item_pydata is not None:

   445

            svgpath = item_pydata

   446

            dname = os.path.dirname(svgpath)

   447

            fname = os.path.basename(svgpath)

   448

            hasher = hashlib.new('md5')

   449

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

   450

                while True:

   451

                    buf = afile.read(65536)

   452

                    if len(buf) > 0:

   453

                        hasher.update(buf)

   454

                    else:

   455

                        break

   456

            digest = hasher.hexdigest()

   457

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

   458

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

   459

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

   460

   461

            have_thumb = os.path.exists(thumbpath)

   462

   463

            try:

   464

                if not have_thumb:

   465

                    if not os.path.exists(thumbdir):

   466

                        os.mkdir(thumbdir)

   467

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   468

   469

                self.bmp = wx.Bitmap(thumbpath) if have_thumb else None

   470

   471

                self.selected_SVG = svgpath if have_thumb else None

   472

   473

                self.AnalyseWidgetAndUpdateUI(fname)

   474

   475

                if self.msg:

   476

                    self.staticmsg.Show()

   477

                    self.staticmsg.SetLabel(self.msg)

   478

                else:

   479

                    self.staticmsg.Hide()

   480

   481

   482

            except IOError:

   483

                self.msg = _("Widget library must be writable")

   484

   485

            self.Refresh()

   486

        event.Skip()

   487

   488

    def OnHMITreeNodeSelection(self, hmitree_nodes):

   489

        self.hmitree_nodes = hmitree_nodes