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

from tempfile import NamedTemporaryFile

    14

    15

import wx

    16

from wx.lib.scrolledpanel import ScrolledPanel

    17

    18

from lxml import etree

    19

from lxml.etree import XSLTApplyError

    20

from XSLTransform import XSLTransform

    21

    22

import util.paths as paths

    23

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    24

from docutil import get_inkscape_path

    25

    26

from util.ProcessLogger import ProcessLogger

    27

    28

ScriptDirectory = paths.AbsDir(__file__)

    29

    30

HMITreeDndMagicWord = "text/beremiz-hmitree"

    31

    32

class HMITreeSelector(wx.TreeCtrl):

    33

    def __init__(self, parent):

    34

    35

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

    36

            wx.TR_MULTIPLE |

    37

            wx.TR_HAS_BUTTONS |

    38

            wx.SUNKEN_BORDER |

    39

            wx.TR_LINES_AT_ROOT))

    40

    41

        self.ordered_items = []

    42

        self.parent = parent

    43

    44

        self.MakeTree()

    45

    46

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

    47

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

    48

    49

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    50

        for c in current_hmitree_root.children:

    51

            if hasattr(c, "children"):

    52

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

    53

                               if c.hmiclass is not None else c.name

    54

                tc_child = self.AppendItem(current_tc_root, display_name)

    55

                self.SetPyData(tc_child, c)

    56

    57

                self._recurseTree(c,tc_child)

    58

            else:

    59

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

    60

                tc_child = self.AppendItem(current_tc_root, display_name)

    61

                self.SetPyData(tc_child, c)

    62

    63

    def OnTreeNodeSelection(self, event):

    64

        items = self.GetSelections()

    65

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

    66

    67

        # append new items to ordered item list

    68

        for item_pydata in items_pydata:

    69

            if item_pydata not in self.ordered_items:

    70

                self.ordered_items.append(item_pydata)

    71

    72

        # filter out vanished items

    73

        self.ordered_items = [

    74

            item_pydata 

    75

            for item_pydata in self.ordered_items 

    76

            if item_pydata in items_pydata]

    77

    78

        self.parent.OnHMITreeNodeSelection(self.ordered_items)

    79

    80

    def OnTreeBeginDrag(self, event):

    81

        """

    82

        Called when a drag is started in tree

    83

        @param event: wx.TreeEvent

    84

        """

    85

        if self.ordered_items:

    86

            print("boink")

    87

            # Just send a recognizable mime-type, drop destination

    88

            # will get python data from parent

    89

            data = wx.CustomDataObject(HMITreeDndMagicWord)

    90

            dragSource = wx.DropSource(self)

    91

            dragSource.SetData(data)

    92

            dragSource.DoDragDrop()

    93

    94

    def MakeTree(self, hmi_tree_root=None):

    95

    96

        self.Freeze()

    97

    98

        self.root = None

    99

        self.DeleteAllItems()

   100

   101

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

   102

            if hmi_tree_root is None else "HMI"

   103

        self.root = self.AddRoot(root_display_name)

   104

        self.SetPyData(self.root, hmi_tree_root)

   105

   106

        if hmi_tree_root is not None:

   107

            self._recurseTree(hmi_tree_root, self.root)

   108

            self.Expand(self.root)

   109

   110

        self.Thaw()

   111

   112

class WidgetPicker(wx.TreeCtrl):

   113

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

   114

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

   115

            wx.TR_MULTIPLE |

   116

            wx.TR_HAS_BUTTONS |

   117

            wx.SUNKEN_BORDER |

   118

            wx.TR_LINES_AT_ROOT))

   119

   120

        self.MakeTree(initialdir)

   121

   122

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

   123

        """

   124

        recurse through subdirectories, but creates tree nodes 

   125

        only when (sub)directory conbtains .svg file

   126

        """

   127

        res = []

   128

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

   129

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

   130

            if os.path.isdir(p):

   131

   132

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

   133

                if len(r) > 0 :

   134

                    res = r

   135

                    dirlist = []

   136

                    current_tc_root = res.pop()

   137

   138

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

   139

                if len(dirlist) > 0 :

   140

                    res = []

   141

                    for d in dirlist:

   142

                        current_tc_root = self.AppendItem(current_tc_root, d)

   143

                        res.append(current_tc_root)

   144

                        self.SetPyData(current_tc_root, None)

   145

                    dirlist = []

   146

                    res.pop()

   147

                tc_child = self.AppendItem(current_tc_root, f)

   148

                self.SetPyData(tc_child, p)

   149

        return res

   150

   151

    def MakeTree(self, lib_dir = None):

   152

   153

        self.Freeze()

   154

   155

        self.root = None

   156

        self.DeleteAllItems()

   157

   158

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

   159

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

   160

        self.root = self.AddRoot(root_display_name)

   161

        self.SetPyData(self.root, None)

   162

   163

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

   164

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

   165

            self.Expand(self.root)

   166

   167

        self.Thaw()

   168

   169

class PathDropTarget(wx.DropTarget):

   170

   171

    def __init__(self, parent):

   172

        data = wx.CustomDataObject(HMITreeDndMagicWord)

   173

        wx.DropTarget.__init__(self, data)

   174

        self.ParentWindow = parent

   175

   176

    def OnDrop(self, x, y):

   177

        self.ParentWindow.OnHMITreeDnD()

   178

        return True

   179

   180

class ParamEditor(wx.Panel):

   181

    def __init__(self, parent, paramdesc):

   182

   183

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

   184

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

   185

        if paramdesc.text:

   186

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

   187

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

   188

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

   189

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

   190

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

   191

        self.edit = wx.TextCtrl(self)

   192

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

   193

        self.edit_sizer.AddGrowableCol(0)

   194

        self.edit_sizer.AddGrowableRow(0)

   195

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

   196

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

   197

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

   198

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

   199

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

   200

        self.SetSizer(self.main_sizer)

   201

        self.main_sizer.Fit(self)

   202

   203

    def setValidityNOK(self):

   204

        self.validity_sbmp.SetBitmap(self.invalid_bmp)

   205

        self.validity_sbmp.Show(True)

   206

   207

    def setValidityOK(self):

   208

        self.validity_sbmp.SetBitmap(self.valid_bmp)

   209

        self.validity_sbmp.Show(True)

   210

   211

    def setValidityUnknown(self):

   212

        self.validity_sbmp.Show(False)

   213

   214

class ArgEditor(ParamEditor):

   215

    pass

   216

   217

class PathEditor(ParamEditor):

   218

    def __init__(self, parent, pathdesc):

   219

        ParamEditor.__init__(self, parent, pathdesc)

   220

        self.ParentObj = parent

   221

        self.pathdesc = pathdesc

   222

        DropTarget = PathDropTarget(self)

   223

        self.edit.SetDropTarget(DropTarget)

   224

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

   225

   226

    def OnHMITreeDnD(self):

   227

        self.ParentObj.GotPathDnDOn(self)

   228

   229

    def SetPath(self, hmitree_node):

   230

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

   231

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

   232

            self.setValidityOK()

   233

        else:

   234

            self.setValidityNOK()

   235

   236

    def OnPathChanged(self, event):

   237

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

   238

        # Lazy way : hide validity

   239

        self.setValidityUnknown()

   240

        event.Skip()

   241

   242

   243

_conf_key = "SVGHMIWidgetLib"

   244

_preview_height = 200

   245

_preview_margin = 5

   246

class WidgetLibBrowser(wx.SplitterWindow):

   247

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

   248

                 size=wx.DefaultSize):

   249

   250

        wx.SplitterWindow.__init__(self, parent,

   251

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   252

   253

        self.bmp = None

   254

        self.msg = None

   255

        self.hmitree_nodes = []

   256

        self.selected_SVG = None

   257

   258

        self.Config = wx.ConfigBase.Get()

   259

        self.libdir = self.RecallLibDir()

   260

   261

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

   262

   263

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

   264

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

   265

        self.picker_sizer.AddGrowableCol(0)

   266

        self.picker_sizer.AddGrowableRow(1)

   267

   268

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

   269

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

   270

   271

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

   272

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

   273

        self.picker_sizer.Layout()

   274

        self.picker_panel.SetAutoLayout(True)

   275

        self.picker_panel.SetSizer(self.picker_sizer)

   276

   277

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

   278

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

   279

   280

   281

   282

        self.main_panel = ScrolledPanel(parent=self,

   283

                                                name='MiscellaneousPanel',

   284

                                                style=wx.TAB_TRAVERSAL)

   285

   286

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

   287

        self.main_sizer.AddGrowableCol(0)

   288

        self.main_sizer.AddGrowableRow(2)

   289

   290

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

   291

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

   292

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

   293

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

   294

                                     _("Widget's arguments"),

   295

                                     style = wx.ALIGN_RIGHT)

   296

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

   297

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

   298

                                      _("Widget's variables"),

   299

                                      style = wx.ALIGN_RIGHT)

   300

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

   301

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

   302

        self.signature_sizer.AddSpacer(5)

   303

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

   304

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

   305

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

   306

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

   307

        self.main_sizer.Layout()

   308

        self.main_panel.SetAutoLayout(True)

   309

        self.main_panel.SetSizer(self.main_sizer)

   310

        self.main_sizer.Fit(self.main_panel)

   311

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

   312

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

   313

   314

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

   315

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   316

   317

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

   318

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

   319

   320

        self.tempf = None 

   321

   322

        self.args_editors = []

   323

        self.paths_editors = []

   324

   325

    def ResetSignature(self):

   326

        self.args_sizer.Clear()

   327

        for editor in self.args_editors:

   328

            editor.Destroy()

   329

        self.args_editors = []

   330

   331

        self.paths_sizer.Clear()

   332

        for editor in self.paths_editors:

   333

            editor.Destroy()

   334

        self.paths_editors = []

   335

   336

    def AddArgToSignature(self, arg):

   337

        new_editor = ArgEditor(self, arg)

   338

        self.args_editors.append(new_editor)

   339

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

   340

   341

    def AddPathToSignature(self, path):

   342

        new_editor = PathEditor(self, path)

   343

        self.paths_editors.append(new_editor)

   344

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

   345

   346

    def GotPathDnDOn(self, target_editor):

   347

        dndindex = self.paths_editors.index(target_editor)

   348

   349

        for hmitree_node,editor in zip(self.hmitree_nodes,

   350

                                   self.paths_editors[dndindex:]):

   351

            editor.SetPath(hmitree_node)

   352

   353

    def RecallLibDir(self):

   354

        conf = self.Config.Read(_conf_key)

   355

        if len(conf) == 0:

   356

            return None

   357

        else:

   358

            return DecodeFileSystemPath(conf)

   359

   360

    def RememberLibDir(self, path):

   361

        self.Config.Write(_conf_key,

   362

                          EncodeFileSystemPath(path))

   363

        self.Config.Flush()

   364

   365

    def DrawPreview(self):

   366

        """

   367

        Refresh preview panel 

   368

        """

   369

        # Init preview panel paint device context

   370

        dc = wx.PaintDC(self.preview)

   371

        dc.Clear()

   372

   373

        if self.bmp:

   374

            # Get Preview panel size

   375

            sz = self.preview.GetClientSize()

   376

            w = self.bmp.GetWidth()

   377

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

   378

   379

   380

   381

    def OnSelectLibDir(self, event):

   382

        defaultpath = self.RecallLibDir()

   383

        if defaultpath == None:

   384

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

   385

   386

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

   387

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   388

   389

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

   390

            self.libdir = dialog.GetPath()

   391

            self.RememberLibDir(self.libdir)

   392

            self.widgetpicker.MakeTree(self.libdir)

   393

   394

        dialog.Destroy()

   395

   396

    def OnPaint(self, event):

   397

        """

   398

        Called when Preview panel needs to be redrawn

   399

        @param event: wx.PaintEvent

   400

        """

   401

        self.DrawPreview()

   402

        event.Skip()

   403

   404

    def GenThumbnail(self, svgpath, thumbpath):

   405

        inkpath = get_inkscape_path()

   406

        if inkpath is None:

   407

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

   408

            return False

   409

        # TODO: spawn a thread, to decouple thumbnail gen

   410

        status, result, _err_result = ProcessLogger(

   411

            None,

   412

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

   413

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

   414

        if status != 0:

   415

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

   416

            return False

   417

        return True

   418

   419

    def OnWidgetSelection(self, event):

   420

        """

   421

        Called when tree item is selected

   422

        @param event: wx.TreeEvent

   423

        """

   424

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

   425

        if item_pydata is not None:

   426

            svgpath = item_pydata

   427

            dname = os.path.dirname(svgpath)

   428

            fname = os.path.basename(svgpath)

   429

            hasher = hashlib.new('md5')

   430

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

   431

                while True:

   432

                    buf = afile.read(65536)

   433

                    if len(buf) > 0:

   434

                        hasher.update(buf)

   435

                    else:

   436

                        break

   437

            digest = hasher.hexdigest()

   438

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

   439

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

   440

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

   441

   442

            have_thumb = os.path.exists(thumbpath)

   443

   444

            try:

   445

                if not have_thumb:

   446

                    if not os.path.exists(thumbdir):

   447

                        os.mkdir(thumbdir)

   448

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   449

   450

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

   451

   452

                self.selected_SVG = svgpath if have_thumb else None

   453

   454

                self.AnalyseWidgetAndUpdateUI(fname)

   455

   456

                if self.msg:

   457

                    self.staticmsg.Show()

   458

                    self.staticmsg.SetLabel(self.msg)

   459

                else:

   460

                    self.staticmsg.Hide()

   461

   462

   463

            except IOError:

   464

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

   465

   466

            self.Refresh()

   467

        event.Skip()

   468

   469

    def OnHMITreeNodeSelection(self, hmitree_nodes):

   470

        self.hmitree_nodes = hmitree_nodes

   471

        # [0] if len(hmitree_nodes) else None

   472

        # self.ValidateWidget()

   473

        # self.Refresh()

   474

   475

    def OnLeftDown(self, evt):

   476

        if self.tempf is not None:

   477

            filename = self.tempf.name

   478

            data = wx.FileDataObject()

   479

            data.AddFile(filename)

   480

            dropSource = wx.DropSource(self)

   481

            dropSource.SetData(data)

   482

            dropSource.DoDragDrop(wx.Drag_AllowMove)

   483

   484

    def GiveDetails(self, _context, msgs):

   485

        for msg in msgs:

   486

            self.msg += msg.text + "\n"

   487

   488

    def PassMessage(self, _context, msgs):

   489

        for msg in msgs: