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

    16

from operator import or_

    17

from tempfile import NamedTemporaryFile

    18

    19

import wx

    20

from wx.lib.scrolledpanel import ScrolledPanel

    21

    22

from lxml import etree

    23

from lxml.etree import XSLTApplyError

    24

from XSLTransform import XSLTransform

    25

    26

import util.paths as paths

    27

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    28

from docutil import get_inkscape_path

    29

    30

from util.ProcessLogger import ProcessLogger

    31

    32

ScriptDirectory = paths.AbsDir(__file__)

    33

    34

HMITreeDndMagicWord = "text/beremiz-hmitree"

    35

    36

class HMITreeSelector(wx.TreeCtrl):

    37

    def __init__(self, parent):

    38

    39

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

    40

            wx.TR_MULTIPLE |

    41

            wx.TR_HAS_BUTTONS |

    42

            wx.SUNKEN_BORDER |

    43

            wx.TR_LINES_AT_ROOT))

    44

    45

        self.ordered_items = []

    46

        self.parent = parent

    47

    48

        self.MakeTree()

    49

    50

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

    51

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

    52

    53

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    54

        for c in current_hmitree_root.children:

    55

            if hasattr(c, "children"):

    56

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

    57

                               if c.hmiclass is not None else c.name

    58

                tc_child = self.AppendItem(current_tc_root, display_name)

    59

                self.SetPyData(tc_child, c)

    60

    61

                self._recurseTree(c,tc_child)

    62

            else:

    63

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

    64

                tc_child = self.AppendItem(current_tc_root, display_name)

    65

                self.SetPyData(tc_child, c)

    66

    67

    def OnTreeNodeSelection(self, event):

    68

        items = self.GetSelections()

    69

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

    70

    71

        # append new items to ordered item list

    72

        for item_pydata in items_pydata:

    73

            if item_pydata not in self.ordered_items:

    74

                self.ordered_items.append(item_pydata)

    75

    76

        # filter out vanished items

    77

        self.ordered_items = [

    78

            item_pydata 

    79

            for item_pydata in self.ordered_items 

    80

            if item_pydata in items_pydata]

    81

    82

        self.parent.OnHMITreeNodeSelection(self.ordered_items)

    83

    84

    def OnTreeBeginDrag(self, event):

    85

        """

    86

        Called when a drag is started in tree

    87

        @param event: wx.TreeEvent

    88

        """

    89

        if self.ordered_items:

    90

            print("boink")

    91

            # Just send a recognizable mime-type, drop destination

    92

            # will get python data from parent

    93

            data = wx.CustomDataObject(HMITreeDndMagicWord)

    94

            dragSource = wx.DropSource(self)

    95

            dragSource.SetData(data)

    96

            dragSource.DoDragDrop()

    97

    98

    def MakeTree(self, hmi_tree_root=None):

    99

   100

        self.Freeze()

   101

   102

        self.root = None

   103

        self.DeleteAllItems()

   104

   105

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

   106

            if hmi_tree_root is None else "HMI"

   107

        self.root = self.AddRoot(root_display_name)

   108

        self.SetPyData(self.root, hmi_tree_root)

   109

   110

        if hmi_tree_root is not None:

   111

            self._recurseTree(hmi_tree_root, self.root)

   112

            self.Expand(self.root)

   113

   114

        self.Thaw()

   115

   116

class WidgetPicker(wx.TreeCtrl):

   117

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

   118

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

   119

            wx.TR_MULTIPLE |

   120

            wx.TR_HAS_BUTTONS |

   121

            wx.SUNKEN_BORDER |

   122

            wx.TR_LINES_AT_ROOT))

   123

   124

        self.MakeTree(initialdir)

   125

   126

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

   127

        """

   128

        recurse through subdirectories, but creates tree nodes 

   129

        only when (sub)directory conbtains .svg file

   130

        """

   131

        res = []

   132

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

   133

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

   134

            if os.path.isdir(p):

   135

   136

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

   137

                if len(r) > 0 :

   138

                    res = r

   139

                    dirlist = []

   140

                    current_tc_root = res.pop()

   141

   142

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

   143

                if len(dirlist) > 0 :

   144

                    res = []

   145

                    for d in dirlist:

   146

                        current_tc_root = self.AppendItem(current_tc_root, d)

   147

                        res.append(current_tc_root)

   148

                        self.SetPyData(current_tc_root, None)

   149

                    dirlist = []

   150

                    res.pop()

   151

                tc_child = self.AppendItem(current_tc_root, f)

   152

                self.SetPyData(tc_child, p)

   153

        return res

   154

   155

    def MakeTree(self, lib_dir = None):

   156

   157

        self.Freeze()

   158

   159

        self.root = None

   160

        self.DeleteAllItems()

   161

   162

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

   163

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

   164

        self.root = self.AddRoot(root_display_name)

   165

        self.SetPyData(self.root, None)

   166

   167

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

   168

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

   169

            self.Expand(self.root)

   170

   171

        self.Thaw()

   172

   173

class PathDropTarget(wx.DropTarget):

   174

   175

    def __init__(self, parent):

   176

        data = wx.CustomDataObject(HMITreeDndMagicWord)

   177

        wx.DropTarget.__init__(self, data)

   178

        self.ParentWindow = parent

   179

   180

    def OnDrop(self, x, y):

   181

        self.ParentWindow.OnHMITreeDnD()

   182

        return True

   183

   184

class ParamEditor(wx.Panel):

   185

    def __init__(self, parent, paramdesc):

   186

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

   208

        if validity is not None:

   209

            bmp = self.valid_bmp if validity else self.invalid_bmp

   210

            self.validity_sbmp.SetBitmap(bmp)

   211

            self.validity_sbmp.Show(True)

   212

        else :

   213

            self.validity_sbmp.Show(False)

   214

   215

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

   216

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

   219

   220

class ArgEditor(ParamEditor):

   222

        ParamEditor.__init__(self, parent, argdesc)

   223

        self.ParentObj = parent

   224

        self.argdesc = argdesc

   225

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

   230

   231

    def OnArgChanged(self, event):

   232

        txt = self.edit.GetValue()

   233

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

   234

        self.setValidity(

   235

            reduce(or_,

   236

                   map(lambda typename: 

   237

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

   238

                       accepts), 

   239

                   False)

   240

            if accepts and txt else None)

   241

        event.Skip()

   242

   243

class PathEditor(ParamEditor):

   244

    def __init__(self, parent, pathdesc):

   245

        ParamEditor.__init__(self, parent, pathdesc)

   246

        self.ParentObj = parent

   247

        self.pathdesc = pathdesc

   248

        DropTarget = PathDropTarget(self)

   249

        self.edit.SetDropTarget(DropTarget)

   250

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

   251

   252

    def OnHMITreeDnD(self):

   253

        self.ParentObj.GotPathDnDOn(self)

   254

   255

    def SetPath(self, hmitree_node):

   256

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

   257

        self.setValidity(

   258

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

   259

   260

    def OnPathChanged(self, event):

   261

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

   262

        # Lazy way : hide validity

   263

        self.setValidity(None)

   264

        event.Skip()

   265

   270

   271

_conf_key = "SVGHMIWidgetLib"

   272

_preview_height = 200

   273

_preview_margin = 5

   274

class WidgetLibBrowser(wx.SplitterWindow):

   275

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

   276

                 size=wx.DefaultSize):

   277

   278

        wx.SplitterWindow.__init__(self, parent,

   279

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   280

   281

        self.bmp = None

   282

        self.msg = None

   283

        self.hmitree_nodes = []

   284

        self.selected_SVG = None

   285

   286

        self.Config = wx.ConfigBase.Get()

   287

        self.libdir = self.RecallLibDir()

   288

   289

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

   290

   291

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

   292

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

   293

        self.picker_sizer.AddGrowableCol(0)

   294

        self.picker_sizer.AddGrowableRow(1)

   295

   296

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

   297

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

   298

   299

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

   300

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

   301

        self.picker_sizer.Layout()

   302

        self.picker_panel.SetAutoLayout(True)

   303

        self.picker_panel.SetSizer(self.picker_sizer)

   304

   305

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

   306

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

   307

   308

   309

   310

        self.main_panel = ScrolledPanel(parent=self,

   311

                                                name='MiscellaneousPanel',

   312

                                                style=wx.TAB_TRAVERSAL)

   313

   314

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

   315

        self.main_sizer.AddGrowableCol(0)

   316

        self.main_sizer.AddGrowableRow(2)

   317

   318

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

   319

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

   320

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

   321

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

   322

                                     _("Widget's arguments"),

   324

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

   325

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

   326

                                      _("Widget's variables"),

   328

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

   329

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

   330

        self.signature_sizer.AddSpacer(5)

   331

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

   332

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

   333

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

   334

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

   335

        self.main_sizer.Layout()

   336

        self.main_panel.SetAutoLayout(True)

   337

        self.main_panel.SetSizer(self.main_sizer)

   338

        self.main_sizer.Fit(self.main_panel)

   339

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

   340

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

   341

   342

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

   343

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   344

   345

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

   346

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

   347

   348

        self.tempf = None 

   349

   350

        self.args_editors = []

   351

        self.paths_editors = []

   352

   353

    def ResetSignature(self):

   354

        self.args_sizer.Clear()

   355

        for editor in self.args_editors:

   356

            editor.Destroy()

   357

        self.args_editors = []

   358

   359

        self.paths_sizer.Clear()

   360

        for editor in self.paths_editors:

   361

            editor.Destroy()

   362

        self.paths_editors = []

   363

   366

        self.args_editors.append(new_editor)

   367

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

   368

   369

    def AddPathToSignature(self, path):

   370

        new_editor = PathEditor(self, path)

   371

        self.paths_editors.append(new_editor)

   372

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

   373

   374

    def GotPathDnDOn(self, target_editor):

   375

        dndindex = self.paths_editors.index(target_editor)

   376

   377

        for hmitree_node,editor in zip(self.hmitree_nodes,

   378

                                   self.paths_editors[dndindex:]):

   379

            editor.SetPath(hmitree_node)

   380

   381

    def RecallLibDir(self):

   382

        conf = self.Config.Read(_conf_key)

   383

        if len(conf) == 0:

   384

            return None

   385

        else:

   386

            return DecodeFileSystemPath(conf)

   387

   388

    def RememberLibDir(self, path):

   389

        self.Config.Write(_conf_key,

   390

                          EncodeFileSystemPath(path))

   391

        self.Config.Flush()

   392

   393

    def DrawPreview(self):

   394

        """

   395

        Refresh preview panel 

   396

        """

   397

        # Init preview panel paint device context

   398

        dc = wx.PaintDC(self.preview)

   399

        dc.Clear()

   400

   401

        if self.bmp:

   402

            # Get Preview panel size

   403

            sz = self.preview.GetClientSize()

   404

            w = self.bmp.GetWidth()

   405

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

   406

   407

   408

   409

    def OnSelectLibDir(self, event):

   410

        defaultpath = self.RecallLibDir()

   411

        if defaultpath == None:

   412

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

   413

   414

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

   415

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   416

   417

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

   418

            self.libdir = dialog.GetPath()

   419

            self.RememberLibDir(self.libdir)

   420

            self.widgetpicker.MakeTree(self.libdir)

   421

   422

        dialog.Destroy()

   423

   424

    def OnPaint(self, event):

   425

        """

   426

        Called when Preview panel needs to be redrawn

   427

        @param event: wx.PaintEvent

   428

        """

   429

        self.DrawPreview()

   430

        event.Skip()

   431

   432

    def GenThumbnail(self, svgpath, thumbpath):

   433

        inkpath = get_inkscape_path()

   434

        if inkpath is None:

   435

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

   436

            return False

   437

        # TODO: spawn a thread, to decouple thumbnail gen

   438

        status, result, _err_result = ProcessLogger(

   439

            None,

   440

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

   441

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

   442

        if status != 0:

   443

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

   444

            return False

   445

        return True

   446

   447

    def OnWidgetSelection(self, event):

   448

        """

   449

        Called when tree item is selected

   450

        @param event: wx.TreeEvent

   451

        """

   452

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

   453

        if item_pydata is not None:

   454

            svgpath = item_pydata

   455

            dname = os.path.dirname(svgpath)

   456

            fname = os.path.basename(svgpath)

   457

            hasher = hashlib.new('md5')

   458

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

   459

                while True:

   460

                    buf = afile.read(65536)

   461

                    if len(buf) > 0:

   462

                        hasher.update(buf)

   463

                    else:

   464

                        break

   465

            digest = hasher.hexdigest()

   466

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

   467

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

   468

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

   469

   470

            have_thumb = os.path.exists(thumbpath)

   471

   472

            try:

   473

                if not have_thumb:

   474

                    if not os.path.exists(thumbdir):

   475

                        os.mkdir(thumbdir)

   476

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   477

   478

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

   479

   480

                self.selected_SVG = svgpath if have_thumb else None

   481

   482

                self.AnalyseWidgetAndUpdateUI(fname)

   483

   484

                if self.msg:

   485

                    self.staticmsg.Show()

   486

                    self.staticmsg.SetLabel(self.msg)

   487

                else:

   488

                    self.staticmsg.Hide()

   489