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

_conf_key = "SVGHMIWidgetLib"

   130

_preview_height = 200

   131

class WidgetLibBrowser(wx.Panel):

   132

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

   133

                 size=wx.DefaultSize):

   134

   135

        wx.Panel.__init__(self, parent, id, pos, size)     

   136

   137

        self.bmp = None

   138

        self.msg = None

   139

        self.hmitree_node = None

   140

        self.selected_SVG = None

   141

   142

        self.Config = wx.ConfigBase.Get()

   143

        self.libdir = self.RecallLibDir()

   144

   145

        sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=4, vgap=0)

   146

        sizer.AddGrowableCol(0)

   147

        sizer.AddGrowableRow(1)

   148

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

   149

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

   150

        self.preview = wx.Panel(self, size=(-1, _preview_height + 10))

   151

        self.comment = wx.TextCtrl(self, size=wx.Size(-1, 80),

   152

                                   style=wx.TE_READONLY | wx.TE_MULTILINE)

   153

        sizer.AddWindow(self.libbutton, flag=wx.GROW)

   154

        sizer.AddWindow(self.widgetpicker, flag=wx.GROW)

   155

        sizer.AddWindow(self.preview, flag=wx.GROW)

   156

        sizer.AddWindow(self.comment, flag=wx.GROW)

   157

        sizer.Layout()

   158

        self.SetAutoLayout(True)

   159

        self.SetSizer(sizer)

   160

        sizer.Fit(self)

   161

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

   162

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

   163

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

   164

   165

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

   166

   167

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

   168

        self.tempf = None 

   169

   170

    def RecallLibDir(self):

   171

        conf = self.Config.Read(_conf_key)

   172

        if len(conf) == 0:

   173

            return None

   174

        else:

   175

            return DecodeFileSystemPath(conf)

   176

   177

    def RememberLibDir(self, path):

   178

        self.Config.Write(_conf_key,

   179

                          EncodeFileSystemPath(path))

   180

        self.Config.Flush()

   181

   182

    def DrawPreview(self):

   183

        """

   184

        Refresh preview panel 

   185

        """

   186

        # Init preview panel paint device context

   187

        dc = wx.PaintDC(self.preview)

   188

        dc.Clear()

   189

   190

        if self.bmp:

   191

            # Get Preview panel size

   192

            sz = self.preview.GetClientSize()

   193

            w = self.bmp.GetWidth()

   194

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

   195

   196

        self.comment.SetValue(self.msg)

   197

   198

   199

    def OnSelectLibDir(self, event):

   200

        defaultpath = self.RecallLibDir()

   201

        if defaultpath == None:

   202

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

   203

   204

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

   205

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   206

   207

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

   208

            self.libdir = dialog.GetPath()

   209

            self.RememberLibDir(self.libdir)

   210

            self.widgetpicker.MakeTree(self.libdir)

   211

   212

        dialog.Destroy()

   213

   214

    def OnPaint(self, event):

   215

        """

   216

        Called when Preview panel needs to be redrawn

   217

        @param event: wx.PaintEvent

   218

        """

   219

        self.DrawPreview()

   220

        event.Skip()

   221

   222

    def GenThumbnail(self, svgpath, thumbpath):

   223

        inkpath = get_inkscape_path()

   224

        if inkpath is None:

   225

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

   226

            return False

   227

        # TODO: spawn a thread, to decouple thumbnail gen

   228

        status, result, _err_result = ProcessLogger(

   229

            None,

   230

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

   231

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

   232

        if status != 0:

   233

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

   234

            return False

   235

        return True

   236

   237

    def OnWidgetSelection(self, event):

   238

        """

   239

        Called when tree item is selected

   240

        @param event: wx.TreeEvent

   241

        """

   242

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

   243

        if item_pydata is not None:

   244

            svgpath = item_pydata

   245

            dname = os.path.dirname(svgpath)

   246

            fname = os.path.basename(svgpath)

   247

            hasher = hashlib.new('md5')

   248

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

   249

                while True:

   250

                    buf = afile.read(65536)

   251

                    if len(buf) > 0:

   252

                        hasher.update(buf)

   253

                    else:

   254

                        break

   255

            digest = hasher.hexdigest()

   256

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

   257

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

   258

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

   259

   260

            have_thumb = os.path.exists(thumbpath)

   261

   262

            try:

   263

                if not have_thumb:

   264

                    if not os.path.exists(thumbdir):

   265

                        os.mkdir(thumbdir)

   266

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   267

   268

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

   269

   270

                self.selected_SVG = svgpath if have_thumb else None

   271

                self.ValidateWidget()

   272

            except IOError:

   273

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

   274

   275

            self.Refresh()

   276

        event.Skip()

   277

   278

    def OnHMITreeNodeSelection(self, hmitree_nodes):

   279

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

   280

        self.ValidateWidget()

   281

        self.Refresh()

   282

   283

    def OnLeftDown(self, evt):

   284

        if self.tempf is not None:

   285

            filename = self.tempf.name

   286

            data = wx.FileDataObject()

   287

            data.AddFile(filename)

   288

            dropSource = wx.DropSource(self)

   289

            dropSource.SetData(data)

   290

            dropSource.DoDragDrop(wx.Drag_AllowMove)

   291

   292

    def GiveDetails(self, _context, msgs):

   293

        for msg in msgs:

   294

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

   295

   296

    def PassMessage(self, _context, msgs):

   297

        for msg in msgs:

   298

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

   299

   300

    def GetSubHMITree(self, _context):

   301

        return [self.hmitree_node.etree()]

   340

   341

    def ValidateWidget(self):

   342

        self.msg = ""

   343

   350

        if self.tempf is not None:

   351

            os.unlink(self.tempf.name)

   352

            self.tempf = None

   353

   354

        try:

   355

            if self.selected_SVG is None:

   356

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

   357

            if self.hmitree_node is None:

   358

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

   359

   360

            transform = XSLTransform(

   361

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

   362

                [("GetSubHMITree", self.GetSubHMITree),

   363

                 ("PassMessage", self.GiveDetails)])

   364

   365

            svgdom = etree.parse(self.selected_SVG)

   366

   367

            result = transform.transform(

   368

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

   369

   370

            for entry in transform.get_error_log():

   371

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

   372

   373

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

   374

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

   375

            self.tempf.close()

   376

   377

        except Exception as e:

   378

            self.msg += str(e)

   379

        except XSLTApplyError as e:

   380

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

   381

   382

    def __del__(self):

   383

        if self.tempf is not None:

   384

            os.unlink(self.tempf.name)

   385

   386

class SVGHMI_UI(wx.SplitterWindow):

   387

   388

    def __init__(self, parent, register_for_HMI_tree_updates):

   389

        wx.SplitterWindow.__init__(self, parent,

   390

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   391

   392

        self.ordered_items = []

   393

   394

        self.SelectionTree = HMITreeSelector(self)

   395

        self.Staging = WidgetLibBrowser(self)

   396

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

   397

        register_for_HMI_tree_updates(weakref.ref(self))

   398

        self.Bind(wx.EVT_TREE_SEL_CHANGED,

   399

            self.OnHMITreeNodeSelection, self.SelectionTree)

   400

   401

    def OnHMITreeNodeSelection(self, event):

   402

        items = self.SelectionTree.GetSelections()

   403

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

   404

   405

        # append new items to ordered item list

   406

        for item_pydata in items_pydata:

   407

            if item_pydata not in self.ordered_items:

   408

                self.ordered_items.append(item_pydata)

   409

   410

        # filter out vanished items

   411

        self.ordered_items = [

   412

            item_pydata 

   413

            for item_pydata in self.ordered_items 

   414

            if item_pydata in items_pydata]

   415

   416

        self.Staging.OnHMITreeNodeSelection(items_pydata)

   417

   418

    def HMITreeUpdate(self, hmi_tree_root):

   419

            self.SelectionTree.MakeTree(hmi_tree_root)

   420