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

    14

import wx

    15

    16

from IDEFrame import EncodeFileSystemPath, DecodeFileSystemPath

    17

from docutil import get_inkscape_path

    18

    19

from util.ProcessLogger import ProcessLogger

    20

    21

def SVGHMIEditorUpdater(ref):

    22

    def SVGHMIEditorUpdate():

    23

        o = ref()

    24

        if o is not None:

    25

            wx.CallAfter(o.MakeTree)

    26

    return SVGHMIEditorUpdate

    27

    28

class HMITreeSelector(wx.TreeCtrl):

    29

    def __init__(self, parent):

    30

        global on_hmitree_update

    31

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

    32

            wx.TR_MULTIPLE |

    33

            wx.TR_HAS_BUTTONS |

    34

            wx.SUNKEN_BORDER |

    35

            wx.TR_LINES_AT_ROOT))

    36

    37

        on_hmitree_update = SVGHMIEditorUpdater(weakref.ref(self))

    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, None) # TODO

    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, None) # TODO

    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, None)

    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))  #, style=wx.SIMPLE_BORDER)

   151

        #self.preview.SetBackgroundColour(wx.WHITE)

   152

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

   153

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

   154

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

   155

        sizer.Layout()

   156

        self.SetAutoLayout(True)

   157

        self.SetSizer(sizer)

   158

        sizer.Fit(self)

   159

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

   160

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

   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

   166

    def RecallLibDir(self):

   167

        conf = self.Config.Read(_conf_key)

   168

        if len(conf) == 0:

   169

            return None

   170

        else:

   171

            return DecodeFileSystemPath(conf)

   172

   173

    def RememberLibDir(self, path):

   174

        self.Config.Write(_conf_key,

   175

                          EncodeFileSystemPath(path))

   176

        self.Config.Flush()

   177

   178

    def DrawPreview(self):

   179

        """

   180

        Refresh preview panel 

   181

        """

   182

        # Init preview panel paint device context

   183

        dc = wx.PaintDC(self.preview)

   184

        dc.Clear()

   185

   186

        if self.bmp:

   187

            # Get Preview panel size

   188

            sz = self.preview.GetClientSize()

   189

            w = self.bmp.GetWidth()

   190

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

   191

   192

        if self.msg:

   193

            dc.SetFont(self.GetFont())

   194

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

   195

   196

   197

    def OnSelectLibDir(self, event):

   198

        defaultpath = self.RecallLibDir()

   199

        if defaultpath == None:

   200

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

   201

   202

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

   203

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   204

   205

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

   206

            self.libdir = dialog.GetPath()

   207

            self.RememberLibDir(self.libdir)

   208

            self.widgetpicker.MakeTree(self.libdir)

   209

   210

        dialog.Destroy()

   211

   212

    def OnPaint(self, event):

   213

        """

   214

        Called when Preview panel needs to be redrawn

   215

        @param event: wx.PaintEvent

   216

        """

   217

        self.DrawPreview()

   218

        event.Skip()

   219

   220

    def GenThumbnail(self, svgpath, thumbpath):

   221

        inkpath = get_inkscape_path()

   222

        if inkpath is None:

   223

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

   224

            return False

   225

        # TODO: spawn a thread, to decouple thumbnail gen

   226

        status, result, _err_result = ProcessLogger(

   227

            None,

   228

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

   229

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

   230

        if status != 0:

   231

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

   232

            return False

   233

        return True

   234

   235

    def OnWidgetSelection(self, event):

   236

        """

   237

        Called when tree item is selected

   238

        @param event: wx.TreeEvent

   239

        """

   240

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

   241

        if item_pydata is not None:

   242

            svgpath = item_pydata

   243

            dname = os.path.dirname(svgpath)

   244

            fname = os.path.basename(svgpath)

   245

            hasher = hashlib.new('md5')

   246

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

   247

                while True:

   248

                    buf = afile.read(65536)

   249

                    if len(buf) > 0:

   250

                        hasher.update(buf)

   251

                    else:

   252

                        break

   253

            digest = hasher.hexdigest()

   254

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

   255

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

   256

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

   257

   258

            self.msg = None

   259

            have_thumb = os.path.exists(thumbpath)

   260

   261

            if not have_thumb:

   262

                try:

   263

                    if not os.path.exists(thumbdir):

   264

                        os.mkdir(thumbdir)

   265

                except IOError:

   266

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

   267

                else:

   268

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   269

   270

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

   271

   272

            self.selected_SVG = svgpath if have_thumb else None

   273

            self.ValidateWidget()

   274

   275

            self.Refresh()

   276

        event.Skip()

   277

   278

    def OnHMITreeNodeSelection(self, hmitree_node):

   279

        self.hmitree_node = hmitree_node

   280

        self.ValidateWidget()

   281

        self.Refresh()

   282

   283

    def ValidateWidget(self):

   284

        if self.selected_SVG is not None:

   285

            if self.hmitree_node is not None:

   286

                pass

   287

        # XXX TODO: 

   288

        #      - check SVG is valid for selected HMI tree item

   289

        #      - prepare for D'n'D

   290

   291

   292

class SVGHMI_UI(wx.SplitterWindow):

   293

   294

    def __init__(self, parent, register_for_HMI_tree_updates):

   295

        wx.SplitterWindow.__init__(self, parent,

   296

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   297

   298

        self.SelectionTree = HMITreeSelector(self)

   299

        self.Staging = WidgetLibBrowser(self)

   300

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

   301

        register_for_HMI_tree_updates(weakref.ref(self))

   302

   303

    def HMITreeUpdate(self, hmi_tree_root):

   304

            self.SelectionTree.MakeTree(hmi_tree_root)

   305