1

import os, re, traceback

     2

     3

from copy import deepcopy

     4

from lxml import etree

     5

from xmlclass import GenerateParserFromXSDstring

     6

     7

from PLCControler import UndoBuffer

     8

from ConfigTreeNode import XSDSchemaErrorMessage

     9

    10

CODEFILE_XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

    11

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"

    12

            xmlns:xhtml="http://www.w3.org/1999/xhtml">

    13

  <xsd:element name="%(codefile_name)s">

    14

    <xsd:complexType>

    15

      <xsd:sequence>

    16

        %(includes_section)s

    17

        <xsd:element name="variables">

    18

          <xsd:complexType>

    19

            <xsd:sequence>

    20

              <xsd:element name="variable" minOccurs="0" maxOccurs="unbounded">

    21

                <xsd:complexType>

    22

                  <xsd:attribute name="name" type="xsd:string" use="required"/>

    23

                  <xsd:attribute name="type" type="xsd:string" use="required"/>

    24

                  <xsd:attribute name="class" use="optional">

    25

                    <xsd:simpleType>

    26

                      <xsd:restriction base="xsd:string">

    27

                        <xsd:enumeration value="input"/>

    28

                        <xsd:enumeration value="memory"/>

    29

                        <xsd:enumeration value="output"/>

    30

                      </xsd:restriction>

    31

                    </xsd:simpleType>

    32

                  </xsd:attribute>

    33

                  <xsd:attribute name="initial" type="xsd:string" use="optional" default=""/>

    34

                  <xsd:attribute name="desc" type="xsd:string" use="optional" default=""/>

    35

                  <xsd:attribute name="onchange" type="xsd:string" use="optional" default=""/>

    36

                  <xsd:attribute name="opts" type="xsd:string" use="optional" default=""/>

    37

                </xsd:complexType>

    38

              </xsd:element>

    39

            </xsd:sequence>

    40

          </xsd:complexType>

    41

        </xsd:element>

    42

        %(sections)s

    43

      </xsd:sequence>

    44

    </xsd:complexType>

    45

  </xsd:element>

    46

  <xsd:complexType name="CodeText">

    47

    <xsd:annotation>

    48

      <xsd:documentation>Formatted text according to parts of XHTML 1.1</xsd:documentation>

    49

    </xsd:annotation>

    50

    <xsd:sequence>

    51

      <xsd:any namespace="http://www.w3.org/1999/xhtml" processContents="lax"/>

    52

    </xsd:sequence>

    53

  </xsd:complexType>

    54

</xsd:schema>"""

    55

    56

SECTION_TAG_ELEMENT = "<xsd:element name=\"%s\" type=\"CodeText\"/>"

    57

    58

class CodeFile:

    59

    60

    CODEFILE_NAME = "CodeFile"

    61

    SECTIONS_NAMES = []

    62

    63

    def __init__(self):

    64

        sections_str = {"codefile_name": self.CODEFILE_NAME}

    65

        if "includes" in self.SECTIONS_NAMES:

    66

            sections_str["includes_section"] = SECTION_TAG_ELEMENT % "includes"

    67

        else:

    68

            sections_str["includes_section"] = ""

    69

        sections_str["sections"] = "\n".join(

    70

            [SECTION_TAG_ELEMENT % name

    71

             for name in self.SECTIONS_NAMES if name != "includes"])

    72

    73

        self.CodeFileParser = GenerateParserFromXSDstring(

    74

            CODEFILE_XSD % sections_str)

    75

        self.CodeFileVariables = etree.XPath("variables/variable")

    76

    77

        filepath = self.CodeFileName()

    78

    79

        if os.path.isfile(filepath):

    80

            xmlfile = open(filepath, 'r')

    81

            codefile_xml = xmlfile.read()

    82

            xmlfile.close()

    83

    84

            codefile_xml = codefile_xml.replace(

    85

                '<%s>' % self.CODEFILE_NAME, 

    86

                '<%s xmlns:xhtml="http://www.w3.org/1999/xhtml">' % self.CODEFILE_NAME)

    87

            for cre, repl in [

    88

                (re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),

    89

                (re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:

    90

                codefile_xml = cre.sub(repl, codefile_xml)

    91

    92

            try:

    93

                self.CodeFile, error = self.CodeFileParser.LoadXMLString(codefile_xml)

    94

                if error is not None:

    95

                    self.GetCTRoot().logger.write_warning(

    96

                        XSDSchemaErrorMessage % ((self.CODEFILE_NAME,) + error))

    97

                self.CreateCodeFileBuffer(True)

    98

            except Exception, exc:

    99

                self.GetCTRoot().logger.write_error(_("Couldn't load confnode parameters %s :\n %s") % (CTNName, unicode(exc)))

   100

                self.GetCTRoot().logger.write_error(traceback.format_exc())

   101

        else:

   102

            self.CodeFile = self.CodeFileParser.CreateRoot()

   103

            self.CreateCodeFileBuffer(False)

   104

            self.OnCTNSave()

   105

   106

    def GetBaseTypes(self):

   107

        return self.GetCTRoot().GetBaseTypes()

   108

   109

    def GetDataTypes(self, basetypes = False):

   110

        return self.GetCTRoot().GetDataTypes(basetypes=basetypes)

   111

   112

    def GenerateNewName(self, format, start_idx):

   113

        return self.GetCTRoot().GenerateNewName(

   114

            None, None, format, start_idx,

   115

            dict([(var.getname().upper(), True) 

   116

                  for var in self.CodeFile.variables.getvariable()]))

   117

   118

    def SetVariables(self, variables):

   119

        self.CodeFile.variables.setvariable([])

   120

        for var in variables:

   121

            variable = self.CodeFileParser.CreateElement("variable", "variables")

   122

            variable.setname(var["Name"])

   123

            variable.settype(var["Type"])

   124

            variable.setinitial(var["Initial"])

   125

            variable.setdesc(var["Description"])

   126

            variable.setonchange(var["OnChange"])

   127

            variable.setopts(var["Options"])

   128

            self.CodeFile.variables.appendvariable(variable)

   129

   130

    def GetVariables(self):

   131

        datas = []

   132

        for var in self.CodeFileVariables(self.CodeFile):

   133

            datas.append({"Name" : var.getname(), 

   134

                          "Type" : var.gettype(), 

   135

                          "Initial" : var.getinitial(),

   136

                          "Description" : var.getdesc(),

   137

                          "OnChange"    : var.getonchange(),

   138

                          "Options"     : var.getopts(),

   139

                         })

   140

        return datas

   141

   142

    def SetTextParts(self, parts):

   143

        for section in self.SECTIONS_NAMES:

   144

            section_code = parts.get(section)

   145

            if section_code is not None:

   146

                getattr(self.CodeFile, section).setanyText(section_code)

   147

   148

    def GetTextParts(self):

   149

        return dict([(section, getattr(self.CodeFile, section).getanyText())

   150

                     for section in self.SECTIONS_NAMES])

   151

   152

    def CTNTestModified(self):

   153

        return self.ChangesToSave or not self.CodeFileIsSaved()    

   154

   155

    def OnCTNSave(self, from_project_path=None):

   156

        filepath = self.CodeFileName()

   157

   158

        xmlfile = open(filepath,"w")

   159

        xmlfile.write(etree.tostring(

   160

            self.CodeFile, 

   161

            pretty_print=True, 

   162

            xml_declaration=True, 

   163

            encoding='utf-8'))

   164

        xmlfile.close()

   165

   166

        self.MarkCodeFileAsSaved()

   167

        return True

   168

   169

    def CTNGlobalInstances(self):

   170

        variables = self.CodeFileVariables(self.CodeFile)

   171

        ret =  [(variable.getname(),

   172

                 variable.gettype(),

   173

                 variable.getinitial()) 

   174

                for variable in variables]

   175

        ret.extend([("On"+variable.getname()+"Change", "python_poll", "")

   176

                for variable in variables

   177

                if variable.getonchange()])

   178

        return ret

   179

   180

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

   181

#                      Current Buffering Management Functions

   182

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

   183

   184

    """

   185

    Return a copy of the codefile model

   186

    """

   187

    def Copy(self, model):

   188

        return deepcopy(model)

   189

   190

    def CreateCodeFileBuffer(self, saved):

   191

        self.Buffering = False

   192

        self.CodeFileBuffer = UndoBuffer(self.CodeFileParser.Dumps(self.CodeFile), saved)

   193

   194

    def BufferCodeFile(self):

   195

        self.CodeFileBuffer.Buffering(self.CodeFileParser.Dumps(self.CodeFile))

   196

   197

    def StartBuffering(self):

   198

        self.Buffering = True

   199

   200

    def EndBuffering(self):

   201

        if self.Buffering:

   202

            self.CodeFileBuffer.Buffering(self.CodeFileParser.Dumps(self.CodeFile))

   203

            self.Buffering = False

   204

   205

    def MarkCodeFileAsSaved(self):

   206

        self.EndBuffering()

   207

        self.CodeFileBuffer.CurrentSaved()

   208

   209

    def CodeFileIsSaved(self):

   210

        return self.CodeFileBuffer.IsCurrentSaved() and not self.Buffering

   211

   212

    def LoadPrevious(self):

   213

        self.EndBuffering()

   214

        self.CodeFile = self.CodeFileParser.Loads(self.CodeFileBuffer.Previous())

   215

   216

    def LoadNext(self):

   217

        self.CodeFile = self.CodeFileParser.Loads(self.CodeFileBuffer.Next())

   218

   219

    def GetBufferState(self):

   220

        first = self.CodeFileBuffer.IsFirst() and not self.Buffering

   221

        last = self.CodeFileBuffer.IsLast()

   222

        return not first, not last

   223