1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

# This program is free software; you can redistribute it and/or

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

# of the License, or (at your option) any later version.

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

# You should have received a copy of the GNU General Public License

    23

# along with this program; if not, write to the Free Software

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

    27

    28

import os

    29

import sys

    30

import shutil

    31

from xml.dom import minidom

    32

    33

import wx

    34

    35

from py_ext import PythonFileCTNMixin

    36

    37

    38

class WxGladeHMI(PythonFileCTNMixin):

    39

    40

    ConfNodeMethods = [

    41

        {

    42

            "bitmap":    "editWXGLADE",

    43

            "name":    _("WXGLADE GUI"),

    44

            "tooltip": _("Edit a WxWidgets GUI with WXGlade"),

    45

            "method":   "_editWXGLADE"

    46

        },

    47

    ]

    48

    49

    def GetIconName(self):

    50

        return "wxGlade"

    51

    52

    def _getWXGLADEpath(self, project_path=None):

    53

        if project_path is None:

    54

            project_path = self.CTNPath()

    55

        # define name for wxGlade gui file

    56

        return os.path.join(project_path, "hmi.wxg")

    57

    58

    def GetWxGladePath(self):

    59

        path = None

    60

        try:

    61

            from wxglade import __file__ as fileName

    62

            path = os.path.dirname(fileName)

    63

            return path

    64

        except ImportError:

    65

            pass

    66

    67

        defLibDir = "/usr/share/wxglade"

    68

        if os.path.isdir(defLibDir):

    69

            path = defLibDir

    70

    71

        return path

    72

    73

    def launch_wxglade(self, options, wait=False):

    74

        path = self.GetWxGladePath()

    75

        glade = os.path.join(path, 'wxglade.py')

    76

        if wx.Platform == '__WXMSW__':

    77

            glade = "\"%s\"" % glade

    78

        mode = {False: os.P_NOWAIT, True: os.P_WAIT}[wait]

    79

        os.spawnv(mode, sys.executable,

    80

                  ["\"%s\"" % sys.executable] + [glade] + options)

    81

    82

    def OnCTNSave(self, from_project_path=None):

    83

        if from_project_path is not None:

    84

            shutil.copyfile(self._getWXGLADEpath(from_project_path),

    85

                            self._getWXGLADEpath())

    86

        return PythonFileCTNMixin.OnCTNSave(self, from_project_path)

    87

    88

    def CTNGenerate_C(self, buildpath, locations):

    89

    90

        # list containing description of all objects declared in wxglade

    91

        hmi_objects = []

    92

        # list containing only description of the main frame object

    93

        main_frames = []

    94

    95

        wxgfile_path = self._getWXGLADEpath()

    96

        if os.path.exists(wxgfile_path):

    97

            wxgfile = open(wxgfile_path, 'r')

    98

            wxgtree = minidom.parse(wxgfile)

    99

            wxgfile.close()

   100

   101

            for node in wxgtree.childNodes[1].childNodes:

   102

                if node.nodeType == wxgtree.ELEMENT_NODE:

   103

                    name = node.getAttribute("name")

   104

                    wxglade_object_desc = {

   105

                        "name": name,

   106

                        "class": node.getAttribute("class"),

   107

                        "handlers": [

   108

                            hnode.firstChild.data for hnode in

   109

                            node.getElementsByTagName("handler")]}

   110

   111

                    hmi_objects.append(wxglade_object_desc)

   112

                    if name == self.CTNName():

   113

                        main_frames.append(wxglade_object_desc)

   114

   115

            hmipyfile_path = os.path.join(self._getBuildPath(), "hmi.py")

   116

            if wx.Platform == '__WXMSW__':

   117

                wxgfile_path = "\"%s\"" % wxgfile_path

   118

                wxghmipyfile_path = "\"%s\"" % hmipyfile_path

   119

            else:

   120

                wxghmipyfile_path = hmipyfile_path

   121

            self.launch_wxglade(

   122

                ['-o', wxghmipyfile_path, '-g', 'python', wxgfile_path], wait=True)

   123

   124

            hmipyfile = open(hmipyfile_path, 'r')

   125

            define_hmi = hmipyfile.read().decode('utf-8')

   126

            hmipyfile.close()

   127

   128

        else:

   129

            define_hmi = ""

   130

   131

        global_hmi = ("global %s\n" % ",".join(

   132

            [x["name"] for x in main_frames]) if len(main_frames) > 0 else "")

   133

   134

        declare_hmi = \

   135

            "\n".join(["%(name)s = None\n" % x for x in main_frames]) + \

   136

            "\n".join(["\n".join(["%(class)s.%(h)s = %(h)s" % dict(x, h=h)

   137

                                  for h in x['handlers']])

   138

                       for x in hmi_objects]) + """\

   139

   140

def OnCloseFrame(evt):

   141

    wx.MessageBox(_("Please stop PLC to close"))

   142

   143

def InitHMI():

   144

    """ + global_hmi + "\n" + "\n".join(["""\

   145

    %(name)s = %(class)s(None)

   146

    %(name)s.Bind(wx.EVT_CLOSE, OnCloseFrame)

   147

    %(name)s.Show()

   148

   149

""" % x for x in main_frames]) + """\

   150

def CleanupHMI():

   151

    """ + global_hmi + "\n" + "\n".join(["""\

   152

    if %(name)s is not None:

   153

        %(name)s.Destroy()

   154

""" % x for x in main_frames])

   155

   156

        self.PreSectionsTexts = {

   157

            "globals": define_hmi,

   158

            "start":   global_hmi,

   159

            "stop":    "CleanupHMI()\n"

   160

        }

   161

        self.PostSectionsTexts = {

   162

            "globals": declare_hmi,

   163

            "start":   "InitHMI()\n",

   164

        }

   165

   166

        if len(main_frames) == 0 and \

   167

           len(getattr(self.CodeFile, "start").getanyText().strip()) == 0:

   168

            self.GetCTRoot().logger.write_warning(

   169

                _("Warning: WxGlade HMI has no object with name identical to extension name, and no python code is provided in start section to create object.\n"))

   170

   171

        return PythonFileCTNMixin.CTNGenerate_C(self, buildpath, locations)

   172

   173

    def _editWXGLADE(self):

   174

        wxg_filename = self._getWXGLADEpath()

   175

        open_wxglade = True

   176

        if not self.GetCTRoot().CheckProjectPathPerm():

   177

            dialog = wx.MessageDialog(self.GetCTRoot().AppFrame,

   178

                                      _("You don't have write permissions.\nOpen wxGlade anyway ?"),

   179

                                      _("Open wxGlade"),

   180

                                      wx.YES_NO | wx.ICON_QUESTION)

   181

            open_wxglade = dialog.ShowModal() == wx.ID_YES

   182

            dialog.Destroy()

   183

        if open_wxglade:

   184

            if not os.path.exists(wxg_filename):

   185

                hmi_name = self.BaseParams.getName()

   186

                open(wxg_filename, "w").write("""<?xml version="1.0"?>

   187

    <application path="" name="" class="" option="0" language="python" top_window="%(name)s" encoding="UTF-8" use_gettext="0" overwrite="0" use_new_namespace="1" for_version="2.8" is_template="0">

   188

        <object class="%(class)s" name="%(name)s" base="EditFrame">

   189

            <style>wxDEFAULT_FRAME_STYLE</style>

   190

            <title>frame_1</title>

   191

            <object class="wxBoxSizer" name="sizer_1" base="EditBoxSizer">

   192

                <orient>wxVERTICAL</orient>

   193

            <object class="sizerslot" />

   194

        </object>

   195

        </object>

   196

    </application>

   197

    """ % {"name": hmi_name, "class": "Class_%s" % hmi_name})

   198

            if wx.Platform == '__WXMSW__':

   199

                wxg_filename = "\"%s\"" % wxg_filename

   200

            self.launch_wxglade([wxg_filename])