1

import wx

     2

import os

     3

import modules

     4

from plugger import PlugTemplate, opjimg

     6

from PythonEditor import PythonEditorFrame

     7

     8

from xml.dom import minidom

     9

from xmlclass import *

    10

import cPickle

    11

    12

PythonClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "python_xsd.xsd")) 

    13

    14

class PythonCodeTemplate:

    15

    16

    def __init__(self):

    17

    18

        self.PluginMethods.insert(0, 

    19

                {"bitmap" : opjimg("editPYTHONcode"),

    20

                 "name" : _("Edit Python File"), 

    21

                 "tooltip" : _("Edit Python File"),

    22

                 "method" : "_OpenView"},

    23

        )

    24

    25

        filepath = self.PythonFileName()

    26

    27

        self.Buffering = False

    28

        self.PythonCode = PythonClasses["Python"]()

    29

        self.PythonBuffer = UndoBuffer(self.Copy(self.PythonCode), False)

    30

        if os.path.isfile(filepath):

    31

            xmlfile = open(filepath, 'r')

    32

            tree = minidom.parse(xmlfile)

    33

            xmlfile.close()

    34

    35

            for child in tree.childNodes:

    36

                if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "Python":

    37

                    self.PythonCode.loadXMLTree(child, ["xmlns", "xmlns:xsi", "xsi:schemaLocation"])

    38

                    self.PythonBuffer = UndoBuffer(self.Copy(self.PythonCode), True)

    39

        else:

    40

            self.OnPlugSave()

    41

    42

    def PluginPath(self):

    43

        return os.path.join(self.PlugParent.PluginPath(), "modules", self.PlugType)

    44

    45

    def PythonFileName(self):

    46

        return os.path.join(self.PlugPath(), "python.xml")

    47

    48

    def GetFilename(self):

    49

        if self.PythonBuffer.IsCurrentSaved():

    50

            return "python"

    51

        else:

    52

            return "~python~"

    53

    54

    def SetPythonCode(self, text):

    55

        self.PythonCode.settext(text)

    56

    57

    def GetPythonCode(self):

    58

        return self.PythonCode.gettext()

    59

    60

    _View = None

    61

    def _OpenView(self):

    62

        if not self._View:

    63

            open_pyeditor = True

    64

            has_permissions = self.GetPlugRoot().CheckProjectPathPerm()

    65

            if not has_permissions:

    66

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

    67

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

    68

                                          _("Open PythonEditor"),

    69

                                          wx.YES_NO|wx.ICON_QUESTION)

    70

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

    71

                dialog.Destroy()

    72

            if open_pyeditor:

    73

                def _onclose():

    74

                    self._View = None

    75

                if has_permissions:

    76

                    def _onsave():

    77

                        self.GetPlugRoot().SaveProject()

    78

                else:

    79

                    def _onsave():

    80

                        pass

    81

                self._View = PythonEditorFrame(self.GetPlugRoot().AppFrame, self)

    82

                self._View._onclose = _onclose

    83

                self._View._onsave = _onsave

    84

                self._View.Show()

    85

    86

    def OnPlugSave(self):

    87

        filepath = self.PythonFileName()

    88

    89

        text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"

    90

        extras = {"xmlns":"http://www.w3.org/2001/XMLSchema",

    91

                  "xmlns:xsi":"http://www.w3.org/2001/XMLSchema-instance",

    92

                  "xsi:schemaLocation" : "python_xsd.xsd"}

    93

        text += self.PythonCode.generateXMLText("Python", 0, extras)

    94

    95

        xmlfile = open(filepath,"w")

    96

        xmlfile.write(text.encode("utf-8"))

    97

        xmlfile.close()

    98

    99

        self.PythonBuffer.CurrentSaved()

   100

        return True

   101

   102

#-------------------------------------------------------------------------------

   103

#                      Current Buffering Management Functions

   104

#-------------------------------------------------------------------------------

   105

   106

    """

   107

    Return a copy of the project

   108

    """

   109

    def Copy(self, model):

   110

        return cPickle.loads(cPickle.dumps(model))

   111

   112

    def BufferPython(self):

   113

        self.PythonBuffer.Buffering(self.Copy(self.PythonCode))

   114

   115

    def StartBuffering(self):

   116

        self.PythonBuffer.Buffering(self.PythonCode)

   117

        self.Buffering = True

   118

   119

    def EndBuffering(self):

   120

        if self.Buffering:

   121

            self.PythonCode = self.Copy(self.PythonCode)

   122

            self.Buffering = False

   123

   124

    def PythonCodeIsSaved(self):

   125

        if self.PythonBuffer:

   126

            return self.PythonBuffer.IsCurrentSaved()

   127

        else:

   128

            return True

   129

   130

    def LoadPrevious(self):

   131

        self.PythonCode = self.Copy(self.PythonBuffer.Previous())

   132

   133

    def LoadNext(self):

   134

        self.PythonCode = self.Copy(self.PythonBuffer.Next())

   135

   136

    def GetBufferState(self):

   137

        first = self.PythonBuffer.IsFirst()

   138

        last = self.PythonBuffer.IsLast()

   139

        return not first, not last

   140

   141

def _GetClassFunction(name):

   142

    def GetRootClass():

   143

        __import__("plugins.python.modules." + name)

   144

        return getattr(modules, name).RootClass

   145

    return GetRootClass

   146

   147

class RootClass(PythonCodeTemplate):

   148

   149

    # For root object, available Childs Types are modules of the modules packages.

   150

    PlugChildsTypes = [(name, _GetClassFunction(name), help) for name, help in zip(modules.__all__,modules.helps)]

   151

   152

    def PluginPath(self):

   153

        return os.path.join(self.PlugParent.PluginPath(), self.PlugType)

   154

   155

    def PlugGenerate_C(self, buildpath, locations):

   156

        """

   157

        Generate C code

   158

        @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)

   159

        @param locations: List of complete variables locations \

   160

            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   161

            "NAME" : name of the variable (generally "__IW0_1_2" style)

   162

            "DIR" : direction "Q","I" or "M"

   163

            "SIZE" : size "X", "B", "W", "D", "L"

   164

            "LOC" : tuple of interger for IEC location (0,1,2,...)

   165

            }, ...]

   166

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   167

        """

   168

        current_location = self.GetCurrentLocation()

   169

        # define a unique name for the generated C file

   170

        location_str = "_".join(map(lambda x:str(x), current_location))

   171

   172

        plugin_root = self.GetPlugRoot()

   173

        plugin_root.GetIECProgramsAndVariables()

   174

   175

        plc_python_filepath = os.path.join(os.path.split(__file__)[0], "plc_python.c")

   176

        plc_python_file = open(plc_python_filepath, 'r')

   177

        plc_python_code = plc_python_file.read()

   178

        plc_python_file.close()

   179

        python_eval_fb_list = []

   180

        for v in plugin_root._VariablesList:

   181

            if v["vartype"] == "FB" and v["type"] in ["PYTHON_EVAL","PYTHON_POLL"]:

   182

                python_eval_fb_list.append(v)

   183

        python_eval_fb_count = max(1, len(python_eval_fb_list))

   184

   185

        # prepare python code

   186

        plc_python_code = plc_python_code % {

   187

           "python_eval_fb_count": python_eval_fb_count,

   188

           "location": location_str}

   189

   190

        Gen_Pythonfile_path = os.path.join(buildpath, "python_%s.c"%location_str)

   191

        pythonfile = open(Gen_Pythonfile_path,'w')

   192

        pythonfile.write(plc_python_code)

   193

        pythonfile.close()

   194

   195

        runtimefile_path = os.path.join(buildpath, "runtime_%s.py"%location_str)

   196

        runtimefile = open(runtimefile_path, 'w')

   197

        runtimefile.write(self.GetPythonCode())

   198

        runtimefile.close()

   199

   200

        matiec_flags = '"-I%s"'%os.path.abspath(self.GetPlugRoot().GetIECLibPath())

   201

   202

        return [(Gen_Pythonfile_path, matiec_flags)], "", True, ("runtime_%s.py"%location_str, file(runtimefile_path,"rb"))