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:

   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

class ArgEditor(ParamEditor):

   204

    pass

   205

   206

class PathEditor(ParamEditor):

   207

    def __init__(self, parent, pathdesc):

   208

        ParamEditor.__init__(self, parent, pathdesc)

   209

        self.ParentObj = parent

   210

        DropTarget = PathDropTarget(self)

   211

        self.edit.SetDropTarget(DropTarget)

   212

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

   213

   214

    def OnHMITreeDnD(self):

   215

        self.ParentObj.GotPathDnDOn(self)

   216

   218

        self.edit.SetValue(value)

   219

   220

    def OnPathChanged(self, event):

   221

        # TODO : update validity

   222

        event.Skip()

   223

   224

   225

_conf_key = "SVGHMIWidgetLib"

   226

_preview_height = 200

   227

_preview_margin = 5

   228

class WidgetLibBrowser(wx.SplitterWindow):

   229

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

   230

                 size=wx.DefaultSize):

   231

   232

        wx.SplitterWindow.__init__(self, parent,

   233

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   234

   235

        self.bmp = None

   236

        self.msg = None

   237

        self.hmitree_nodes = []

   238

        self.selected_SVG = None

   239

   240

        self.Config = wx.ConfigBase.Get()

   241

        self.libdir = self.RecallLibDir()

   242

   243

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

   244

   245

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

   246

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

   247

        self.picker_sizer.AddGrowableCol(0)

   248

        self.picker_sizer.AddGrowableRow(1)

   249

   250

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

   251

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

   252

   253

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

   254

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

   255

        self.picker_sizer.Layout()

   256

        self.picker_panel.SetAutoLayout(True)

   257

        self.picker_panel.SetSizer(self.picker_sizer)

   258

   259

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

   260

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

   261

   262

   263

   264

        self.main_panel = ScrolledPanel(parent=self,

   265

                                                name='MiscellaneousPanel',

   266

                                                style=wx.TAB_TRAVERSAL)

   267

   268

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

   269

        self.main_sizer.AddGrowableCol(0)

   270

        self.main_sizer.AddGrowableRow(2)

   271

   272

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

   273

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

   274

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

   275

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

   276

                                     _("Widget's arguments"),

   277

                                     style = wx.ALIGN_RIGHT)

   278

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

   279

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

   280

                                      _("Widget's variables"),

   281

                                      style = wx.ALIGN_RIGHT)

   282

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

   283

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

   284

        self.signature_sizer.AddSpacer(5)

   285

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

   286

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

   287

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

   288

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

   289

        self.main_sizer.Layout()

   290

        self.main_panel.SetAutoLayout(True)

   291

        self.main_panel.SetSizer(self.main_sizer)

   292

        self.main_sizer.Fit(self.main_panel)

   293

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

   294

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

   295

   296

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

   297

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   298

   299

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

   300

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

   301

   302

        self.tempf = None 

   303

   304

        self.args_editors = []

   305

        self.paths_editors = []

   306

   307

    def ResetSignature(self):

   308

        self.args_sizer.Clear()

   309

        for editor in self.args_editors:

   310

            editor.Destroy()

   311

        self.args_editors = []

   312

   313

        self.paths_sizer.Clear()

   314

        for editor in self.paths_editors:

   315

            editor.Destroy()

   316

        self.paths_editors = []

   317

   318

    def AddArgToSignature(self, arg):

   319

        new_editor = ArgEditor(self, arg)

   320

        self.args_editors.append(new_editor)

   321

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

   322

   323

    def AddPathToSignature(self, path):

   324

        new_editor = PathEditor(self, path)

   325

        self.paths_editors.append(new_editor)

   326

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

   327

   328

    def GotPathDnDOn(self, target_editor):

   329

        dndindex = self.paths_editors.index(target_editor)

   330

   331

        for selected,editor in zip(self.hmitree_nodes,

   332

                                   self.paths_editors[dndindex:]):

   333

            editor.SetPath(selected.hmi_path())

   334

   335

    def RecallLibDir(self):

   336

        conf = self.Config.Read(_conf_key)

   337

        if len(conf) == 0:

   338

            return None

   339

        else:

   340

            return DecodeFileSystemPath(conf)

   341

   342

    def RememberLibDir(self, path):

   343

        self.Config.Write(_conf_key,

   344

                          EncodeFileSystemPath(path))

   345

        self.Config.Flush()

   346

   347

    def DrawPreview(self):

   348

        """

   349

        Refresh preview panel 

   350

        """

   351

        # Init preview panel paint device context

   352

        dc = wx.PaintDC(self.preview)

   353

        dc.Clear()

   354

   355

        if self.bmp:

   356

            # Get Preview panel size

   357

            sz = self.preview.GetClientSize()

   358

            w = self.bmp.GetWidth()

   359

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

   360

   361

   362

   363

    def OnSelectLibDir(self, event):

   364

        defaultpath = self.RecallLibDir()

   365

        if defaultpath == None:

   366

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

   367

   368

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

   369

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   370

   371

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

   372

            self.libdir = dialog.GetPath()

   373

            self.RememberLibDir(self.libdir)

   374

            self.widgetpicker.MakeTree(self.libdir)

   375

   376

        dialog.Destroy()

   377

   378

    def OnPaint(self, event):

   379

        """

   380

        Called when Preview panel needs to be redrawn

   381

        @param event: wx.PaintEvent

   382

        """

   383

        self.DrawPreview()

   384

        event.Skip()

   385

   386

    def GenThumbnail(self, svgpath, thumbpath):

   387

        inkpath = get_inkscape_path()

   388

        if inkpath is None:

   389

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

   390

            return False

   391

        # TODO: spawn a thread, to decouple thumbnail gen

   392

        status, result, _err_result = ProcessLogger(

   393

            None,

   394

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

   395

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

   396

        if status != 0:

   397

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

   398

            return False

   399

        return True

   400

   401

    def OnWidgetSelection(self, event):

   402

        """

   403

        Called when tree item is selected

   404

        @param event: wx.TreeEvent

   405

        """

   406

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

   407

        if item_pydata is not None:

   408

            svgpath = item_pydata

   409

            dname = os.path.dirname(svgpath)

   410

            fname = os.path.basename(svgpath)

   411

            hasher = hashlib.new('md5')

   412

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

   413

                while True:

   414

                    buf = afile.read(65536)

   415

                    if len(buf) > 0:

   416

                        hasher.update(buf)

   417

                    else:

   418

                        break

   419

            digest = hasher.hexdigest()

   420

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

   421

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

   422

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

   423

   424

            have_thumb = os.path.exists(thumbpath)

   425

   426

            try:

   427

                if not have_thumb:

   428

                    if not os.path.exists(thumbdir):

   429

                        os.mkdir(thumbdir)

   430

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   431

   432

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

   433

   434

                self.selected_SVG = svgpath if have_thumb else None

   435

   436

                self.AnalyseWidgetAndUpdateUI(fname)

   437

   438

                if self.msg:

   439

                    self.staticmsg.Show()

   440

                    self.staticmsg.SetLabel(self.msg)

   441

                else:

   442

                    self.staticmsg.Hide()

   443

   444

   445

            except IOError:

   446

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

   447

   448

            self.Refresh()

   449

        event.Skip()

   450

   451

    def OnHMITreeNodeSelection(self, hmitree_nodes):

   452

        self.hmitree_nodes = hmitree_nodes

   453

        # [0] if len(hmitree_nodes) else None

   454

        # self.ValidateWidget()

   455

        # self.Refresh()

   456

   457

    def OnLeftDown(self, evt):

   458

        if self.tempf is not None:

   459

            filename = self.tempf.name

   460

            data = wx.FileDataObject()

   461

            data.AddFile(filename)

   462

            dropSource = wx.DropSource(self)

   463

            dropSource.SetData(data)

   464

            dropSource.DoDragDrop(wx.Drag_AllowMove)

   465

   466

    def GiveDetails(self, _context, msgs):

   467

        for msg in msgs:

   468

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

   469

   470

    def PassMessage(self, _context, msgs):

   471

        for msg in msgs:

   472

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

   473

   474

    def GetSubHMITree(self, _context):

   475

        return [self.hmitree_node.etree()]

   476

   477

    def AnalyseWidgetAndUpdateUI(self, fname):

   478

        self.msg = ""

   479

        self.ResetSignature()

   480

   481

        try:

   482

            if self.selected_SVG is None:

   483

                raise Exception(_("No widget selected"))

   484

   485

            transform = XSLTransform(

   486

                os.path.join(ScriptDirectory, "analyse_widget.xslt"),[])

   487

   488

            svgdom = etree.parse(self.selected_SVG)

   489

   490

            signature = transform.transform(svgdom)