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

    17

from lxml import etree

    18

from lxml.etree import XSLTApplyError

    19

from XSLTransform import XSLTransform

    20

    21

import util.paths as paths

    22

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    23

from docutil import get_inkscape_path

    24

    25

from util.ProcessLogger import ProcessLogger

    26

    27

ScriptDirectory = paths.AbsDir(__file__)

    28

    29

class HMITreeSelector(wx.TreeCtrl):

    30

    def __init__(self, parent):

    31

        global on_hmitree_update

    32

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

    33

            wx.TR_MULTIPLE |

    34

            wx.TR_HAS_BUTTONS |

    35

            wx.SUNKEN_BORDER |

    36

            wx.TR_LINES_AT_ROOT))

    37

    38

        self.MakeTree()

    39

    40

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    41

        for c in current_hmitree_root.children:

    42

            if hasattr(c, "children"):

    43

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

    44

                               if c.hmiclass is not None else c.name

    45

                tc_child = self.AppendItem(current_tc_root, display_name)

    46

                self.SetPyData(tc_child, c)

    47

    48

                self._recurseTree(c,tc_child)

    49

            else:

    50

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

    51

                tc_child = self.AppendItem(current_tc_root, display_name)

    52

                self.SetPyData(tc_child, c)

    53

    54

    def MakeTree(self, hmi_tree_root=None):

    55

    56

        self.Freeze()

    57

    58

        self.root = None

    59

        self.DeleteAllItems()

    60

    61

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

    62

            if hmi_tree_root is None else "HMI"

    63

        self.root = self.AddRoot(root_display_name)

    64

        self.SetPyData(self.root, hmi_tree_root)

    65

    66

        if hmi_tree_root is not None:

    67

            self._recurseTree(hmi_tree_root, self.root)

    68

            self.Expand(self.root)

    69

    70

        self.Thaw()

    71

    72

class WidgetPicker(wx.TreeCtrl):

    73

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

    74

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

    75

            wx.TR_MULTIPLE |

    76

            wx.TR_HAS_BUTTONS |

    77

            wx.SUNKEN_BORDER |

    78

            wx.TR_LINES_AT_ROOT))

    79

    80

        self.MakeTree(initialdir)

    81

    82

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

    83

        """

    84

        recurse through subdirectories, but creates tree nodes 

    85

        only when (sub)directory conbtains .svg file

    86

        """

    87

        res = []

    88

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

    89

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

    90

            if os.path.isdir(p):

    91

    92

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

    93

                if len(r) > 0 :

    94

                    res = r

    95

                    dirlist = []

    96

                    current_tc_root = res.pop()

    97

    98

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

    99

                if len(dirlist) > 0 :

   100

                    res = []

   101

                    for d in dirlist:

   102

                        current_tc_root = self.AppendItem(current_tc_root, d)

   103

                        res.append(current_tc_root)

   104

                        self.SetPyData(current_tc_root, None)

   105

                    dirlist = []

   106

                    res.pop()

   107

                tc_child = self.AppendItem(current_tc_root, f)

   108

                self.SetPyData(tc_child, p)

   109

        return res

   110

   111

    def MakeTree(self, lib_dir = None):

   112

   113

        self.Freeze()

   114

   115

        self.root = None

   116

        self.DeleteAllItems()

   117

   118

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

   119

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

   120

        self.root = self.AddRoot(root_display_name)

   121

        self.SetPyData(self.root, None)

   122

   123

        if lib_dir is not None:

   124

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

   125

            self.Expand(self.root)

   126

   127

        self.Thaw()

   128

   129

class PathEditor(wx.Panel):

   130

    def __init__(self, parent, path):

   131

   132

        wx.Panel.__init__(self, parent)

   133

        label = path.get("name") + ": " + path.text + "(" + path.get("accepts") + ")"

   134

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

   135

        self.focus_sbmp = wx.StaticBitmap(self, -1, wx.ArtProvider.GetBitmap(wx.ART_GO_FORWARD, wx.ART_TOOLBAR, (32,32)))

   136

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

   137

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

   138

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

   139

        self.edit = wx.TextCtrl(self)

   140

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

   141

        self.edit_sizer.AddGrowableCol(1)

   142

        self.edit_sizer.AddGrowableRow(0)

   143

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

   144

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

   145

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

   146

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

   147

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

   148

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

   149

        self.SetSizer(self.main_sizer)

   150

        self.main_sizer.Fit(self)

   151

   152

_conf_key = "SVGHMIWidgetLib"

   153

_preview_height = 200

   154

_preview_margin = 5

   155

class WidgetLibBrowser(wx.SplitterWindow):

   156

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

   157

                 size=wx.DefaultSize):

   158

   159

        wx.SplitterWindow.__init__(self, parent,

   160

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   161

   162

        self.bmp = None

   163

        self.msg = None

   164

        self.hmitree_node = None

   165

        self.selected_SVG = None

   166

   167

        self.Config = wx.ConfigBase.Get()

   168

        self.libdir = self.RecallLibDir()

   169

   170

        self.picker_panel = wx.Panel(self)

   171

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

   172

        self.picker_sizer.AddGrowableCol(0)

   173

        self.picker_sizer.AddGrowableRow(1)

   174

   175

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

   176

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

   177

   178

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

   179

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

   180

        self.picker_sizer.Layout()

   181

        self.picker_panel.SetAutoLayout(True)

   182

        self.picker_panel.SetSizer(self.picker_sizer)

   183

   184

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

   185

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

   186

   187

   188

   189

        self.main_panel = wx.Panel(self)

   190

   191

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

   192

        self.main_sizer.AddGrowableCol(0)

   193

        self.main_sizer.AddGrowableRow(2)

   194

   195

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

   196

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

   197

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   198

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

   199

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

   200

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

   201

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

   202

        self.main_sizer.Layout()

   203

        self.main_panel.SetAutoLayout(True)

   204

        self.main_panel.SetSizer(self.main_sizer)

   205

        self.main_sizer.Fit(self.main_panel)

   206

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

   207

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

   208

   210

   211

        self.msg = _("Drag selected Widget from here to Inkscape")

   212

        self.tempf = None 

   213

   214

        self.paths_editors = []

   215

   216

    def ResetSignature(self):

   217

        self.signature_sizer.Clear()

   218

        for editor in self.paths_editors:

   219

            editor.Destroy()

   220

        self.paths_editors = []

   221

        self.main_sizer.Layout()

   222

   223

    def AddPathToSignature(self, path):

   224

        new_editor = PathEditor(self.main_panel, path)

   225

        self.paths_editors.append(new_editor)

   226

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

   227

        self.main_sizer.Layout()

   228

   229

    def RecallLibDir(self):

   230

        conf = self.Config.Read(_conf_key)

   231

        if len(conf) == 0:

   232

            return None

   233

        else:

   234

            return DecodeFileSystemPath(conf)

   235

   236

    def RememberLibDir(self, path):

   237

        self.Config.Write(_conf_key,

   238

                          EncodeFileSystemPath(path))

   239

        self.Config.Flush()

   240

   241

    def DrawPreview(self):

   242

        """

   243

        Refresh preview panel 

   244

        """

   245

        # Init preview panel paint device context

   246

        dc = wx.PaintDC(self.preview)

   247

        dc.Clear()

   248

   249

        if self.bmp:

   250

            # Get Preview panel size

   251

            sz = self.preview.GetClientSize()

   252

            w = self.bmp.GetWidth()

   253

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

   254

   255

        self.desc.SetValue(self.msg)

   256

   257

   258

    def OnSelectLibDir(self, event):

   259

        defaultpath = self.RecallLibDir()

   260

        if defaultpath == None:

   261

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

   262

   263

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

   264

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   265

   266

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

   267

            self.libdir = dialog.GetPath()

   268

            self.RememberLibDir(self.libdir)

   269

            self.widgetpicker.MakeTree(self.libdir)

   270

   271

        dialog.Destroy()

   272

   273

    def OnPaint(self, event):

   274

        """

   275

        Called when Preview panel needs to be redrawn

   276

        @param event: wx.PaintEvent

   277

        """

   278

        self.DrawPreview()

   279

        event.Skip()

   280

   281

    def GenThumbnail(self, svgpath, thumbpath):

   282

        inkpath = get_inkscape_path()

   283

        if inkpath is None:

   284

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

   285

            return False

   286

        # TODO: spawn a thread, to decouple thumbnail gen

   287

        status, result, _err_result = ProcessLogger(

   288

            None,

   289

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

   290

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

   291

        if status != 0:

   292

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

   293

            return False

   294

        return True

   295

   296

    def OnWidgetSelection(self, event):

   297

        """

   298

        Called when tree item is selected

   299

        @param event: wx.TreeEvent

   300

        """

   301

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

   302

        if item_pydata is not None:

   303

            svgpath = item_pydata

   304

            dname = os.path.dirname(svgpath)

   305

            fname = os.path.basename(svgpath)

   306

            hasher = hashlib.new('md5')

   307

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

   308

                while True:

   309

                    buf = afile.read(65536)

   310

                    if len(buf) > 0:

   311

                        hasher.update(buf)

   312

                    else:

   313

                        break

   314

            digest = hasher.hexdigest()

   315

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

   316

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

   317

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

   318

   319

            have_thumb = os.path.exists(thumbpath)

   320

   321

            try:

   322

                if not have_thumb:

   323

                    if not os.path.exists(thumbdir):

   324

                        os.mkdir(thumbdir)

   325

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   326

   327

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

   328

   329

                self.selected_SVG = svgpath if have_thumb else None

   330

   331

                self.AnalyseWidgetAndUpdateUI()

   332

   333

            except IOError:

   334

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

   335

   336

            self.Refresh()

   337

        event.Skip()

   338

   339

    def OnHMITreeNodeSelection(self, hmitree_nodes):

   340

        self.hmitree_node = hmitree_nodes[0] if len(hmitree_nodes) else None

   341

        self.ValidateWidget()

   342

        self.Refresh()

   343

   344

    def OnLeftDown(self, evt):

   345

        if self.tempf is not None:

   346

            filename = self.tempf.name

   347

            data = wx.FileDataObject()

   348

            data.AddFile(filename)

   349

            dropSource = wx.DropSource(self)

   350

            dropSource.SetData(data)

   351

            dropSource.DoDragDrop(wx.Drag_AllowMove)

   352

   353

    def GiveDetails(self, _context, msgs):

   354

        for msg in msgs:

   355

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

   356

   357

    def PassMessage(self, _context, msgs):

   358

        for msg in msgs:

   359

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

   360

   361

    def GetSubHMITree(self, _context):

   362

        return [self.hmitree_node.etree()]

   363

   364

    def AnalyseWidgetAndUpdateUI(self):

   365

        self.msg = ""

   366

   367

        try:

   368

            if self.selected_SVG is None:

   369

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

   370

   371

            transform = XSLTransform(

   372

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

   373

   374

            svgdom = etree.parse(self.selected_SVG)

   375

   376

            signature = transform.transform(svgdom)

   377

   378

            for entry in transform.get_error_log():

   379

                self.msg += "XSLT: " + entry.message + "\n" 

   380

   381

        except Exception as e:

   382

            self.msg += str(e)

   383

        except XSLTApplyError as e:

   384

            self.msg += "Widget analysis error: " + e.message

   385

        else:

   386

   387

            self.ResetSignature()

   388

   389

            print(etree.tostring(signature, pretty_print=True))

   390

            widgets = signature.getroot()

   391

            for defs in widgets.iter("defs"):

   392

   393

                # Keep double newlines (to mark paragraphs)

   394

                self.msg += defs.find("type").text + ":\n" + "\n\n".join(map(

   395

                    lambda s:s.replace("\n"," ").replace("  ", " "), 

   396

                    defs.find("longdesc").text.split("\n\n")))

   397

                for arg in defs.iter("arg"):

   398

                    print(arg.get("name"))

   399

                    print(arg.get("accepts"))

   400

                for path in defs.iter("path"):

   401

                    self.AddPathToSignature(path)

   402

                    print(path.get("name"))

   403

                    print(path.get("accepts"))

   404

   405

            for widget in widgets:

   406

                widget_type = widget.get("type")

   407

                print(widget_type)

   408

                for path in widget.iterchildren("path"):

   409

                    path_value = path.get("value")

   410

                    path_accepts = map(

   411

                        str.strip, path.get("accepts", '')[1:-1].split(','))

   412

                    print(path, path_value, path_accepts)

   413

   414

   415

   416

    def ValidateWidget(self):

   417

        self.msg = ""

   418

   419

        if self.tempf is not None:

   420

            os.unlink(self.tempf.name)

   421

            self.tempf = None

   422

   423

        try:

   424

            if self.selected_SVG is None:

   425

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

   426

            if self.hmitree_node is None:

   427

                raise Exception(_("No HMI tree node selected"))

   428

   429

            transform = XSLTransform(

   430

                os.path.join(ScriptDirectory, "gen_dnd_widget_svg.xslt"),

   431

                [("GetSubHMITree", self.GetSubHMITree),

   432

                 ("PassMessage", self.GiveDetails)])

   433

   434

            svgdom = etree.parse(self.selected_SVG)

   435

   436

            result = transform.transform(

   437

                svgdom, hmi_path = self.hmitree_node.hmi_path())

   438

   439

            for entry in transform.get_error_log():

   440

                self.msg += "XSLT: " + entry.message + "\n" 

   441

   442

            self.tempf = NamedTemporaryFile(suffix='.svg', delete=False)

   443

            result.write(self.tempf, encoding="utf-8")

   444

            self.tempf.close()

   445

   446

        except Exception as e:

   447

            self.msg += str(e)

   448

        except XSLTApplyError as e:

   449

            self.msg += "Widget transform error: " + e.message

   450

   451

    def __del__(self):

   452

        if self.tempf is not None:

   453

            os.unlink(self.tempf.name)

   454

   455

class SVGHMI_UI(wx.SplitterWindow):

   456

   457

    def __init__(self, parent, register_for_HMI_tree_updates):

   458

        wx.SplitterWindow.__init__(self, parent,

   459

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   460

   461

        self.ordered_items = []

   462

   463

        self.SelectionTree = HMITreeSelector(self)

   464

        self.Staging = WidgetLibBrowser(self)

   465

        self.SplitVertically(self.SelectionTree, self.Staging, 300)

   466

        register_for_HMI_tree_updates(weakref.ref(self))

   467

        self.Bind(wx.EVT_TREE_SEL_CHANGED,

   468

            self.OnHMITreeNodeSelection, self.SelectionTree)

   469

   470

    def OnHMITreeNodeSelection(self, event):

   471

        items = self.SelectionTree.GetSelections()

   472

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

   473

   474

        # append new items to ordered item list

   475

        for item_pydata in items_pydata:

   476

            if item_pydata not in self.ordered_items:

   477

                self.ordered_items.append(item_pydata)

   478

   479

        # filter out vanished items

   480

        self.ordered_items = [

   481

            item_pydata 

   482

            for item_pydata in self.ordered_items 

   483

            if item_pydata in items_pydata]

   484

   485

        self.Staging.OnHMITreeNodeSelection(items_pydata)

   486

   487

    def HMITreeUpdate(self, hmi_tree_root):

   488

            self.SelectionTree.MakeTree(hmi_tree_root)

   489