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=3, 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

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

   152

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

   153

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

   154

        sizer.Layout()

   155

        self.SetAutoLayout(True)

   156

        self.SetSizer(sizer)

   157

        sizer.Fit(self)

   158

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

   159

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

   160

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

   161

   162

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

   163

   164

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

   165

        self.tempf = None 

   166

   167

    def RecallLibDir(self):

   168

        conf = self.Config.Read(_conf_key)

   169

        if len(conf) == 0:

   170

            return None

   171

        else:

   172

            return DecodeFileSystemPath(conf)

   173

   174

    def RememberLibDir(self, path):

   175

        self.Config.Write(_conf_key,

   176

                          EncodeFileSystemPath(path))

   177

        self.Config.Flush()

   178

   179

    def DrawPreview(self):

   180

        """

   181

        Refresh preview panel 

   182

        """

   183

        # Init preview panel paint device context

   184

        dc = wx.PaintDC(self.preview)

   185

        dc.Clear()

   186

   187

        if self.bmp:

   188

            # Get Preview panel size

   189

            sz = self.preview.GetClientSize()

   190

            w = self.bmp.GetWidth()

   191

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

   192

   193

        if self.msg:

   194

            dc.SetFont(self.GetFont())

   195

            dc.DrawText(self.msg, 25,25)

   196

   197

   198

    def OnSelectLibDir(self, event):

   199

        defaultpath = self.RecallLibDir()

   200

        if defaultpath == None:

   201

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

   202

   203

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

   204

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   205

   206

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

   207

            self.libdir = dialog.GetPath()

   208

            self.RememberLibDir(self.libdir)

   209

            self.widgetpicker.MakeTree(self.libdir)

   210

   211

        dialog.Destroy()

   212

   213

    def OnPaint(self, event):

   214

        """

   215

        Called when Preview panel needs to be redrawn

   216

        @param event: wx.PaintEvent

   217

        """

   218

        self.DrawPreview()

   219

        event.Skip()

   220

   221

    def GenThumbnail(self, svgpath, thumbpath):

   222

        inkpath = get_inkscape_path()

   223

        if inkpath is None:

   224

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

   225

            return False

   226

        # TODO: spawn a thread, to decouple thumbnail gen

   227

        status, result, _err_result = ProcessLogger(

   228

            None,

   229

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

   230

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

   231

        if status != 0:

   232

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

   233

            return False

   234

        return True

   235

   236

    def OnWidgetSelection(self, event):

   237

        """

   238

        Called when tree item is selected

   239

        @param event: wx.TreeEvent

   240

        """

   241

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

   242

        if item_pydata is not None:

   243

            svgpath = item_pydata

   244

            dname = os.path.dirname(svgpath)

   245

            fname = os.path.basename(svgpath)

   246

            hasher = hashlib.new('md5')

   247

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

   248

                while True:

   249

                    buf = afile.read(65536)

   250

                    if len(buf) > 0:

   251

                        hasher.update(buf)

   252

                    else:

   253

                        break

   254

            digest = hasher.hexdigest()

   255

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

   256

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

   257

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

   258

   259

            have_thumb = os.path.exists(thumbpath)

   260

   261

            try:

   262

                if not have_thumb:

   263

                    if not os.path.exists(thumbdir):

   264

                        os.mkdir(thumbdir)

   265

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   266

   267

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

   268

   269

                self.selected_SVG = svgpath if have_thumb else None

   270

                self.ValidateWidget()

   271

            except IOError:

   272

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

   273

   274

            self.Refresh()

   275

        event.Skip()

   276

   277

    def OnHMITreeNodeSelection(self, hmitree_node):

   278

        self.hmitree_node = hmitree_node

   279

        self.ValidateWidget()

   280

        self.Refresh()

   281

   282

    def OnLeftDown(self, evt):

   283

        if self.tempf is not None:

   284

            filename = self.tempf.name

   285

            data = wx.FileDataObject()

   286

            data.AddFile(filename)

   287

            dropSource = wx.DropSource(self)

   288

            dropSource.SetData(data)

   289

            dropSource.DoDragDrop(wx.Drag_AllowMove)

   290

   291

    def GiveDetails(self, _context, msgs):

   292

        for msg in msgs:

   294

   298

    def ValidateWidget(self):

   299

        self.msg = ""

   300

   301

        if self.tempf is not None:

   302

            os.unlink(self.tempf.name)

   303

            self.tempf = None

   304

   305

        try:

   306

            if self.selected_SVG is None:

   307

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

   308

            if self.hmitree_node is None:

   309

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

   310

   311

            transform = XSLTransform(

   312

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

   315

   316

            svgdom = etree.parse(self.selected_SVG)

   317

   319

   320

            for entry in transform.get_error_log():

   321

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

   322

   323

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

   324

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

   325

            self.tempf.close()

   326

   327

        except Exception as e:

   328

            self.msg += str(e)

   329

        except XSLTApplyError as e:

   330

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

   331

   332

    def __del__(self):

   333

        if self.tempf is not None:

   334

            os.unlink(self.tempf.name)

   335

   336

class SVGHMI_UI(wx.SplitterWindow):

   337

   338

    def __init__(self, parent, register_for_HMI_tree_updates):

   339

        wx.SplitterWindow.__init__(self, parent,

   340

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   341

   342

        self.SelectionTree = HMITreeSelector(self)

   343

        self.Staging = WidgetLibBrowser(self)

   344

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

   345

        register_for_HMI_tree_updates(weakref.ref(self))

   346

        self.Bind(wx.EVT_TREE_SEL_CHANGED,

   347

            self.OnHMITreeNodeSelection, self.SelectionTree)

   348

   349

    def OnHMITreeNodeSelection(self, event):

   350

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

   351

        self.Staging.OnHMITreeNodeSelection(item_pydata)

   352

   353

    def HMITreeUpdate(self, hmi_tree_root):

   354

            self.SelectionTree.MakeTree(hmi_tree_root)

   355