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 GetSubHMITree(self, _context):

   297

        return [self.hmitree_node.etree()]

   298

   299

    def ValidateWidget(self):

   300

        self.msg = ""

   301

   302

        if self.tempf is not None:

   303

            os.unlink(self.tempf.name)

   304

            self.tempf = None

   305

   306

        try:

   307

            if self.selected_SVG is None:

   308

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

   309

            if self.hmitree_node is None:

   310

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

   311

   312

            transform = XSLTransform(

   313

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

   314

                [("GetSubHMITree", self.GetSubHMITree),

   315

                 ("GiveDetails", self.GiveDetails)])

   316

   317

            svgdom = etree.parse(self.selected_SVG)

   318

   319

            result = transform.transform(

   320

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

   321

   322

            for entry in transform.get_error_log():

   323

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

   324

   325

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

   326

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

   327

            self.tempf.close()

   328

   329

        except Exception as e:

   330

            self.msg += str(e)

   331

        except XSLTApplyError as e:

   332

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

   333

   334

    def __del__(self):

   335

        if self.tempf is not None:

   336

            os.unlink(self.tempf.name)

   337

   338

class SVGHMI_UI(wx.SplitterWindow):

   339

   340

    def __init__(self, parent, register_for_HMI_tree_updates):

   341

        wx.SplitterWindow.__init__(self, parent,

   342

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   343

   344

        self.ordered_items = []

   345

   346

        self.SelectionTree = HMITreeSelector(self)

   347

        self.Staging = WidgetLibBrowser(self)

   348

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

   349

        register_for_HMI_tree_updates(weakref.ref(self))

   350

        self.Bind(wx.EVT_TREE_SEL_CHANGED,

   351

            self.OnHMITreeNodeSelection, self.SelectionTree)

   352

   353

    def OnHMITreeNodeSelection(self, event):

   354

        items = self.SelectionTree.GetSelections()

   355

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

   356

   357

        # append new items to ordered item list

   358

        for item_pydata in items_pydata:

   359

            if item_pydata not in self.ordered_items:

   360

                self.ordered_items.append(item_pydata)

   361

   362

        # filter out vanished items

   363

        self.ordered_items = [

   364

            item_pydata 

   365

            for item_pydata in self.ordered_items 

   366

            if item_pydata in items_pydata]

   367

   368

        self.Staging.OnHMITreeNodeSelection(items_pydata)

   369

   370

    def HMITreeUpdate(self, hmi_tree_root):

   371

            self.SelectionTree.MakeTree(hmi_tree_root)

   372