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

    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

    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

   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)