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

class HMITreeSelector(wx.TreeCtrl):

    22

    def __init__(self, parent):

    23

        global on_hmitree_update

    24

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

    25

            wx.TR_MULTIPLE |

    26

            wx.TR_HAS_BUTTONS |

    27

            wx.SUNKEN_BORDER |

    28

            wx.TR_LINES_AT_ROOT))

    29

    30

        self.MakeTree()

    31

    32

    def _recurseTree(self, current_hmitree_root, current_tc_root):

    33

        for c in current_hmitree_root.children:

    34

            if hasattr(c, "children"):

    35

                display_name = ('{} (class={})'.format(c.name, c.hmiclass)) \

    36

                               if c.hmiclass is not None else c.name

    37

                tc_child = self.AppendItem(current_tc_root, display_name)

    38

                self.SetPyData(tc_child, None) # TODO

    39

    40

                self._recurseTree(c,tc_child)

    41

            else:

    42

                display_name = '{} {}'.format(c.nodetype[4:], c.name)

    43

                tc_child = self.AppendItem(current_tc_root, display_name)

    44

                self.SetPyData(tc_child, None) # TODO

    45

    46

    def MakeTree(self, hmi_tree_root=None):

    47

    48

        self.Freeze()

    49

    50

        self.root = None

    51

        self.DeleteAllItems()

    52

    53

        root_display_name = _("Please build to see HMI Tree") \

    54

            if hmi_tree_root is None else "HMI"

    55

        self.root = self.AddRoot(root_display_name)

    56

        self.SetPyData(self.root, None)

    57

    58

        if hmi_tree_root is not None:

    59

            self._recurseTree(hmi_tree_root, self.root)

    60

            self.Expand(self.root)

    61

    62

        self.Thaw()

    63

    64

class WidgetPicker(wx.TreeCtrl):

    65

    def __init__(self, parent, initialdir=None):

    66

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

    67

            wx.TR_MULTIPLE |

    68

            wx.TR_HAS_BUTTONS |

    69

            wx.SUNKEN_BORDER |

    70

            wx.TR_LINES_AT_ROOT))

    71

    72

        self.MakeTree(initialdir)

    73

    74

    def _recurseTree(self, current_dir, current_tc_root, dirlist):

    75

        """

    76

        recurse through subdirectories, but creates tree nodes 

    77

        only when (sub)directory conbtains .svg file

    78

        """

    79

        res = []

    80

        for f in sorted(os.listdir(current_dir)):

    81

            p = os.path.join(current_dir,f)

    82

            if os.path.isdir(p):

    83

    84

                r = self._recurseTree(p, current_tc_root, dirlist + [f])

    85

                if len(r) > 0 :

    86

                    res = r

    87

                    dirlist = []

    88

                    current_tc_root = res.pop()

    89

    90

            elif os.path.splitext(f)[1].upper() == ".SVG":

    91

                if len(dirlist) > 0 :

    92

                    res = []

    93

                    for d in dirlist:

    94

                        current_tc_root = self.AppendItem(current_tc_root, d)

    95

                        res.append(current_tc_root)

    96

                        self.SetPyData(current_tc_root, None)

    97

                    dirlist = []

    98

                    res.pop()

    99

                tc_child = self.AppendItem(current_tc_root, f)

   100

                self.SetPyData(tc_child, p)

   101

        return res

   102

   103

    def MakeTree(self, lib_dir = None):

   104

   105

        self.Freeze()

   106

   107

        self.root = None

   108

        self.DeleteAllItems()

   109

   110

        root_display_name = _("Please select widget library directory") \

   111

            if lib_dir is None else os.path.basename(lib_dir)

   112

        self.root = self.AddRoot(root_display_name)

   113

        self.SetPyData(self.root, None)

   114

   115

        if lib_dir is not None:

   116

            self._recurseTree(lib_dir, self.root, [])

   117

            self.Expand(self.root)

   118

   119

        self.Thaw()

   120

   121

_conf_key = "SVGHMIWidgetLib"

   122

_preview_height = 200

   123

class WidgetLibBrowser(wx.Panel):

   124

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

   125

                 size=wx.DefaultSize):

   126

   127

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

   128

   129

        self.bmp = None

   130

        self.msg = None

   131

        self.hmitree_node = None

   132

        self.selected_SVG = None

   133

   134

        self.Config = wx.ConfigBase.Get()

   135

        self.libdir = self.RecallLibDir()

   136

   137

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

   138

        sizer.AddGrowableCol(0)

   139

        sizer.AddGrowableRow(1)

   140

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

   141

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

   142

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

   143

        #self.preview.SetBackgroundColour(wx.WHITE)

   144

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

   145

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

   146

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

   147

        sizer.Layout()

   148

        self.SetAutoLayout(True)

   149

        self.SetSizer(sizer)

   150

        sizer.Fit(self)

   151

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

   152

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

   153

   154

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

   155

   156

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

   157

   158

    def RecallLibDir(self):

   159

        conf = self.Config.Read(_conf_key)

   160

        if len(conf) == 0:

   161

            return None

   162

        else:

   163

            return DecodeFileSystemPath(conf)

   164

   165

    def RememberLibDir(self, path):

   166

        self.Config.Write(_conf_key,

   167

                          EncodeFileSystemPath(path))

   168

        self.Config.Flush()

   169

   170

    def DrawPreview(self):

   171

        """

   172

        Refresh preview panel 

   173

        """

   174

        # Init preview panel paint device context

   175

        dc = wx.PaintDC(self.preview)

   176

        dc.Clear()

   177

   178

        if self.bmp:

   179

            # Get Preview panel size

   180

            sz = self.preview.GetClientSize()

   181

            w = self.bmp.GetWidth()

   182

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

   183

   184

        if self.msg:

   185

            dc.SetFont(self.GetFont())

   186

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

   187

   188

   189

    def OnSelectLibDir(self, event):

   190

        defaultpath = self.RecallLibDir()

   191

        if defaultpath == None:

   192

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

   193

   194

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

   195

                              style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)

   196

   197

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

   198

            self.libdir = dialog.GetPath()

   199

            self.RememberLibDir(self.libdir)

   200

            self.widgetpicker.MakeTree(self.libdir)

   201

   202

        dialog.Destroy()

   203

   204

    def OnPaint(self, event):

   205

        """

   206

        Called when Preview panel needs to be redrawn

   207

        @param event: wx.PaintEvent

   208

        """

   209

        self.DrawPreview()

   210

        event.Skip()

   211

   212

    def GenThumbnail(self, svgpath, thumbpath):

   213

        inkpath = get_inkscape_path()

   214

        if inkpath is None:

   215

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

   216

            return False

   217

        # TODO: spawn a thread, to decouple thumbnail gen

   218

        status, result, _err_result = ProcessLogger(

   219

            None,

   220

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

   221

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

   222

        if status != 0:

   223

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

   224

            return False

   225

        return True

   226

   227

    def OnWidgetSelection(self, event):

   228

        """

   229

        Called when tree item is selected

   230

        @param event: wx.TreeEvent

   231

        """

   232

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

   233

        if item_pydata is not None:

   234

            svgpath = item_pydata

   235

            dname = os.path.dirname(svgpath)

   236

            fname = os.path.basename(svgpath)

   237

            hasher = hashlib.new('md5')

   238

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

   239

                while True:

   240

                    buf = afile.read(65536)

   241

                    if len(buf) > 0:

   242

                        hasher.update(buf)

   243

                    else:

   244

                        break

   245

            digest = hasher.hexdigest()

   246

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

   247

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

   248

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

   249

   250

            self.msg = None

   251

            have_thumb = os.path.exists(thumbpath)

   252

   253

            if not have_thumb:

   254

                try:

   255

                    if not os.path.exists(thumbdir):

   256

                        os.mkdir(thumbdir)

   257

                except IOError:

   258

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

   259

                else:

   260

                    have_thumb = self.GenThumbnail(svgpath, thumbpath)

   261

   262

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

   263

   264

            self.selected_SVG = svgpath if have_thumb else None

   265

            self.ValidateWidget()

   266

   267

            self.Refresh()

   268

        event.Skip()

   269

   270

    def OnHMITreeNodeSelection(self, hmitree_node):

   271

        self.hmitree_node = hmitree_node

   272

        self.ValidateWidget()

   273

        self.Refresh()

   274

   275

    def ValidateWidget(self):

   276

        if self.selected_SVG is not None:

   277

            if self.hmitree_node is not None:

   278

                pass

   279

        # XXX TODO: 

   280

        #      - check SVG is valid for selected HMI tree item

   281

        #      - prepare for D'n'D

   282

   283

   284

class SVGHMI_UI(wx.SplitterWindow):

   285

   286

    def __init__(self, parent, register_for_HMI_tree_updates):

   287

        wx.SplitterWindow.__init__(self, parent,

   288

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   289

   290

        self.SelectionTree = HMITreeSelector(self)

   291

        self.Staging = WidgetLibBrowser(self)

   292

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

   293

        register_for_HMI_tree_updates(weakref.ref(self))

   294

   295

    def HMITreeUpdate(self, hmi_tree_root):

   296

            self.SelectionTree.MakeTree(hmi_tree_root)

   297