1

import wx

     2

import os

     3

import modules

     4

from plugger import PlugTemplate, opjimg

     5

from PythonEditor import PythonEditorFrame

     6

     7

from xml.dom import minidom

     8

from xmlclass import *

     9

import cPickle

    10

    11

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

    12

    13

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

    14

#                         Undo Buffer for PythonCode

    15

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

    16

    17

# Length of the buffer

    18

UNDO_BUFFER_LENGTH = 20

    19

    20

"""

    21

Class implementing a buffer of changes made on the current editing model

    22

"""

    23

class UndoBuffer:

    24

    25

    # Constructor initialising buffer

    26

    def __init__(self, currentstate, issaved = False):

    27

        self.Buffer = []

    28

        self.CurrentIndex = -1

    29

        self.MinIndex = -1

    30

        self.MaxIndex = -1

    31

        # if current state is defined

    32

        if currentstate:

    33

            self.CurrentIndex = 0

    34

            self.MinIndex = 0

    35

            self.MaxIndex = 0

    36

        # Initialising buffer with currentstate at the first place

    37

        for i in xrange(UNDO_BUFFER_LENGTH):

    38

            if i == 0:

    39

                self.Buffer.append(currentstate)

    40

            else:

    41

                self.Buffer.append(None)

    42

        # Initialising index of state saved

    43

        if issaved:

    44

            self.LastSave = 0

    45

        else:

    46

            self.LastSave = -1

    47

    48

    # Add a new state in buffer

    49

    def Buffering(self, currentstate):

    50

        self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH

    51

        self.Buffer[self.CurrentIndex] = currentstate

    52

        # Actualising buffer limits

    53

        self.MaxIndex = self.CurrentIndex

    54

        if self.MinIndex == self.CurrentIndex:

    55

            # If the removed state was the state saved, there is no state saved in the buffer

    56

            if self.LastSave == self.MinIndex:

    57

                self.LastSave = -1

    58

            self.MinIndex = (self.MinIndex + 1) % UNDO_BUFFER_LENGTH

    59

        self.MinIndex = max(self.MinIndex, 0)

    60

    61

    # Return current state of buffer

    62

    def Current(self):

    63

        return self.Buffer[self.CurrentIndex]

    64

    65

    # Change current state to previous in buffer and return new current state

    66

    def Previous(self):

    67

        if self.CurrentIndex != self.MinIndex:

    68

            self.CurrentIndex = (self.CurrentIndex - 1) % UNDO_BUFFER_LENGTH

    69

            return self.Buffer[self.CurrentIndex]

    70

        return None

    71

    72

    # Change current state to next in buffer and return new current state

    73

    def Next(self):

    74

        if self.CurrentIndex != self.MaxIndex:

    75

            self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH

    76

            return self.Buffer[self.CurrentIndex]

    77

        return None

    78

    79

    # Return True if current state is the first in buffer

    80

    def IsFirst(self):

    81

        return self.CurrentIndex == self.MinIndex

    82

    83

    # Return True if current state is the last in buffer

    84

    def IsLast(self):

    85

        return self.CurrentIndex == self.MaxIndex

    86

    87

    # Note that current state is saved

    88

    def CurrentSaved(self):

    89

        self.LastSave = self.CurrentIndex

    90

    91

    # Return True if current state is saved

    92

    def IsCurrentSaved(self):

    93

        return self.LastSave == self.CurrentIndex

    94

    95

class PythonCodeTemplate:

    96

    97

    def __init__(self):

    98

    99

        self.PluginMethods.insert(0, 

   100

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

   101

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

   102

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

   103

                 "method" : "_OpenView"},

   104

        )

   105

   106

        filepath = self.PythonFileName()

   107

   108

        self.Buffering = False

   109

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

   110

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

   111

        if os.path.isfile(filepath):

   112

            xmlfile = open(filepath, 'r')

   113

            tree = minidom.parse(xmlfile)

   114

            xmlfile.close()

   115

   116

            for child in tree.childNodes:

   117

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

   118

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

   119

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

   120

        else:

   121

            self.OnPlugSave()

   122

   123

    def PluginPath(self):

   124

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

   125

   126

    def PythonFileName(self):

   127

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

   128

   129

    def GetFilename(self):

   130

        if self.PythonBuffer.IsCurrentSaved():

   131

            return "python"

   132

        else:

   133

            return "~python~"

   134

   135

    def SetPythonCode(self, text):

   136

        self.PythonCode.settext(text)

   137

   138

    def GetPythonCode(self):

   139

        return self.PythonCode.gettext()

   140

   141

    _View = None

   142

    def _OpenView(self):

   143

        if not self._View:

   144

            def _onclose():

   145

                self._View = None

   146

            def _onsave():

   147

                self.GetPlugRoot().SaveProject()

   148

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

   149

            self._View._onclose = _onclose

   150

            self._View._onsave = _onsave

   151

            self._View.Show()

   152

   153

    def OnPlugSave(self):

   154

        filepath = self.PythonFileName()

   155

   156

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

   157

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

   158

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

   159

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

   160

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

   161

   162

        xmlfile = open(filepath,"w")

   163

        xmlfile.write(text)

   164

        xmlfile.close()

   165

   166

        self.PythonBuffer.CurrentSaved()

   167

        return True

   168

   169

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

   170

#                      Current Buffering Management Functions

   171

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

   172

   173

    """

   174

    Return a copy of the project

   175

    """

   176

    def Copy(self, model):

   177

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

   178

   179

    def BufferPython(self):

   180

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

   181

   182

    def StartBuffering(self):

   183

        self.PythonBuffer.Buffering(self.PythonCode)

   184

        self.Buffering = True

   185

   186

    def EndBuffering(self):

   187

        if self.Buffering:

   188

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

   189

            self.Buffering = False

   190

   191

    def PythonCodeIsSaved(self):

   192

        if self.PythonBuffer:

   193

            return self.PythonBuffer.IsCurrentSaved()

   194

        else:

   195

            return True

   196

   197

    def LoadPrevious(self):

   198

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

   199

   200

    def LoadNext(self):

   201

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

   202

   203

    def GetBufferState(self):

   204

        first = self.PythonBuffer.IsFirst()

   205

        last = self.PythonBuffer.IsLast()

   206

        return not first, not last

   207

   208

def _GetClassFunction(name):

   209

    def GetRootClass():

   210

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

   211

        return getattr(modules, name).RootClass

   212

    return GetRootClass

   213

   214

class RootClass(PythonCodeTemplate):

   215

   216

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

   217

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

   218

   219

    def PluginPath(self):

   220

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

   221

   222

    def PlugGenerate_C(self, buildpath, locations):

   223

        """

   224

        Generate C code

   225

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

   226

        @param locations: List of complete variables locations \

   227

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

   228

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

   229

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

   230

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

   231

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

   232

            }, ...]

   233

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

   234

        """

   235

        current_location = self.GetCurrentLocation()

   236

        # define a unique name for the generated C file

   237

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

   238

   239

        plugin_root = self.GetPlugRoot()

   240

        plugin_root.GetIECProgramsAndVariables()

   241

   242

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

   243

        plc_python_file = open(plc_python_filepath, 'r')

   244

        plc_python_code = plc_python_file.read()

   245

        plc_python_file.close()

   246

        python_eval_fb_list = []

   247

        for v in plugin_root._VariablesList:

   248

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

   249

                python_eval_fb_list.append(v)

   250

        python_eval_fb_count = max(1, len(python_eval_fb_list))

   251

   252

        # prepare python code

   253

        plc_python_code = plc_python_code % {

   254

           "python_eval_fb_count": python_eval_fb_count,

   255

           "location": location_str}

   256

   257

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

   258

        pythonfile = open(Gen_Pythonfile_path,'w')

   259

        pythonfile.write(plc_python_code)

   260

        pythonfile.close()

   261

   262

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

   263

        runtimefile = open(runtimefile_path, 'w')

   264

        runtimefile.write(self.GetPythonCode())

   265

        runtimefile.close()

   266

   267

        if wx.Platform == '__WXMSW__':

   268

            matiec_flags = " -I../../matiec/lib"

   269

        else:

   270

            matiec_flags = " -I../matiec/lib"

   271

   272

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