1

import wx

     2

import os

     3

from plugger import PlugTemplate

     4

from CFileEditor import CFileEditor

     5

     6

from xml.dom import minidom

     7

from xmlclass import *

     8

import cPickle

     9

    10

CFileClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "cext_xsd.xsd")) 

    11

    12

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

    13

#                         Undo Buffer for CFile

    14

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

    15

    16

# Length of the buffer

    17

UNDO_BUFFER_LENGTH = 20

    18

    19

"""

    20

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

    21

"""

    22

class UndoBuffer:

    23

    24

    # Constructor initialising buffer

    25

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

    26

        self.Buffer = []

    27

        self.CurrentIndex = -1

    28

        self.MinIndex = -1

    29

        self.MaxIndex = -1

    30

        # if current state is defined

    31

        if currentstate:

    32

            self.CurrentIndex = 0

    33

            self.MinIndex = 0

    34

            self.MaxIndex = 0

    35

        # Initialising buffer with currentstate at the first place

    36

        for i in xrange(UNDO_BUFFER_LENGTH):

    37

            if i == 0:

    38

                self.Buffer.append(currentstate)

    39

            else:

    40

                self.Buffer.append(None)

    41

        # Initialising index of state saved

    42

        if issaved:

    43

            self.LastSave = 0

    44

        else:

    45

            self.LastSave = -1

    46

    47

    # Add a new state in buffer

    48

    def Buffering(self, currentstate):

    49

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

    50

        self.Buffer[self.CurrentIndex] = currentstate

    51

        # Actualising buffer limits

    52

        self.MaxIndex = self.CurrentIndex

    53

        if self.MinIndex == self.CurrentIndex:

    54

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

    55

            if self.LastSave == self.MinIndex:

    56

                self.LastSave = -1

    57

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

    58

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

    59

    60

    # Return current state of buffer

    61

    def Current(self):

    62

        return self.Buffer[self.CurrentIndex]

    63

    64

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

    65

    def Previous(self):

    66

        if self.CurrentIndex != self.MinIndex:

    67

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

    68

            return self.Buffer[self.CurrentIndex]

    69

        return None

    70

    71

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

    72

    def Next(self):

    73

        if self.CurrentIndex != self.MaxIndex:

    74

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

    75

            return self.Buffer[self.CurrentIndex]

    76

        return None

    77

    78

    # Return True if current state is the first in buffer

    79

    def IsFirst(self):

    80

        return self.CurrentIndex == self.MinIndex

    81

    82

    # Return True if current state is the last in buffer

    83

    def IsLast(self):

    84

        return self.CurrentIndex == self.MaxIndex

    85

    86

    # Note that current state is saved

    87

    def CurrentSaved(self):

    88

        self.LastSave = self.CurrentIndex

    89

    90

    # Return True if current state is saved

    91

    def IsCurrentSaved(self):

    92

        return self.LastSave == self.CurrentIndex

    93

    94

    95

TYPECONVERSION = {"BOOL" : "X", "SINT" : "B", "INT" : "W", "DINT" : "D", "LINT" : "L",

    96

    "USINT" : "B", "UINT" : "W", "UDINT" : "D", "ULINT" : "L", "REAL" : "D", "LREAL" : "L",

    97

    "STRING" : "B", "BYTE" : "B", "WORD" : "W", "DWORD" : "D", "LWORD" : "L", "WSTRING" : "W"}

    98

    99

class _Cfile:

   100

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

   101

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

   102

      <xsd:element name="CExtension">

   103

        <xsd:complexType>

   104

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

   105

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

   106

        </xsd:complexType>

   107

      </xsd:element>

   108

    </xsd:schema>

   109

    """

   110

    def __init__(self):

   111

        filepath = self.CFileName()

   112

   113

        self.Buffering = False

   114

        self.CFile = CFileClasses["CFile"]()

   115

        self.CFileBuffer = UndoBuffer(self.Copy(self.CFile), False)

   116

        if os.path.isfile(filepath):

   117

            xmlfile = open(filepath, 'r')

   118

            tree = minidom.parse(xmlfile)

   119

            xmlfile.close()

   120

   121

            for child in tree.childNodes:

   122

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

   123

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

   124

                    self.CFileBuffer = UndoBuffer(self.Copy(self.CFile), True)

   125

        else:

   126

            self.OnPlugSave()

   127

   128

    def CFileName(self):

   129

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

   130

   131

    def GetFilename(self):

   132

        if self.CFileBuffer.IsCurrentSaved():

   133

            return "cfile"

   134

        else:

   135

            return "~cfile~"

   136

   137

    def GetBaseTypes(self):

   138

        return self.GetPlugRoot().GetBaseTypes()

   139

   140

    def GetDataTypes(self, basetypes = False):

   141

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

   142

   143

    def GetSizeOfType(self, type):

   144

        return TYPECONVERSION[self.GetPlugRoot().GetBaseType(type)]

   145

   146

    def SetVariables(self, variables):

   147

        self.CFile.variables.setvariable([])

   148

        for var in variables:

   149

            variable = CFileClasses["variables_variable"]()

   150

            variable.setname(var["Name"])

   151

            variable.settype(var["Type"])

   152

            variable.setclass(var["Class"])

   153

            self.CFile.variables.appendvariable(variable)

   154

   155

    def GetVariables(self):

   156

        datas = []

   157

        for var in self.CFile.variables.getvariable():

   158

            datas.append({"Name" : var.getname(), "Type" : var.gettype(), "Class" : var.getclass()})

   159

        return datas

   160

   161

    def SetPartText(self, name, text):

   162

        if name == "Includes":

   163

            self.CFile.includes.settext(text)

   164

        elif name == "Globals":

   165

            self.CFile.globals.settext(text)

   166

        elif name == "Init":

   167

            self.CFile.initFunction.settext(text)

   168

        elif name == "CleanUp":

   169

            self.CFile.cleanUpFunction.settext(text)

   170

        elif name == "Retrieve":

   171

            self.CFile.retrieveFunction.settext(text)

   172

        elif name == "Publish":

   173

            self.CFile.publishFunction.settext(text)

   174

   175

    def GetPartText(self, name):

   176

        if name == "Includes":

   177

            return self.CFile.includes.gettext()

   178

        elif name == "Globals":

   179

            return self.CFile.globals.gettext()

   180

        elif name == "Init":

   181

            return self.CFile.initFunction.gettext()

   182

        elif name == "CleanUp":

   183

            return self.CFile.cleanUpFunction.gettext()

   184

        elif name == "Retrieve":

   185

            return self.CFile.retrieveFunction.gettext()

   186

        elif name == "Publish":

   187

            return self.CFile.publishFunction.gettext()

   188

        return ""

   189

   190

    _View = None

   191

    def _OpenView(self):

   192

        if not self._View:

   193

            def _onclose():

   194

                self._View = None

   195

            def _onsave():

   196

                self.GetPlugRoot().SaveProject()

   197

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

   198

            self._View._onclose = _onclose

   199

            self._View._onsave = _onsave

   200

            self._View.Show()

   201

   202

    PluginMethods = [

   203

        {"bitmap" : os.path.join("images", "EditCfile"),

   204

         "name" : "Edit C File", 

   205

         "tooltip" : "Edit C File",

   206

         "method" : "_OpenView"},

   207

    ]

   208

   209

    def OnPlugSave(self):

   210

        filepath = self.CFileName()

   211

   212

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

   213

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

   214

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

   215

                  "xsi:schemaLocation" : "cext_xsd.xsd"}

   216

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

   217

   218

        xmlfile = open(filepath,"w")

   219

        xmlfile.write(text)

   220

        xmlfile.close()

   221

   222

        self.CFileBuffer.CurrentSaved()

   223

        return True

   224

   225

    def PlugGenerate_C(self, buildpath, locations):

   226

        """

   227

        Generate C code

   228

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

   229

        @param locations: List of complete variables locations \

   230

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

   231

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

   232

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

   233

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

   234

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

   235

            }, ...]

   236

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

   237

        """

   238

        current_location = self.GetCurrentLocation()

   239

        # define a unique name for the generated C file

   240

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

   241

   242

        text = "/* Code generated by Beremiz c_ext plugin */\n\n"

   243

   244

        # Adding includes

   245

        text += "/* User includes */\n"

   246

        text += self.CFile.includes.gettext()

   247

        text += "\n"

   248

   249

        text += """/* Beremiz c_ext plugin includes */

   250

#ifdef _WINDOWS_H

   251

  #include "iec_types.h"

   252

#else

   253

  #include "iec_std_lib.h"

   254

#endif

   255

   256

"""

   257

   258

        # Adding variables

   259

        vars = []

   260

        inputs = outputs = 0

   261

        for variable in self.CFile.variables.variable:

   262

            var = {"Name" : variable.getname(), "Type" : variable.gettype()}

   263

            if variable.getclass() == "input":

   264

                var["location"] = "__I%s%s_%d"%(self.GetSizeOfType(var["Type"]), location_str, inputs)

   265

                inputs += 1

   266

            else:

   267

                var["location"] = "__Q%s%s_%d"%(self.GetSizeOfType(var["Type"]), location_str, outputs)

   268

                outputs += 1

   269

            vars.append(var)

   270

        text += "/* Beremiz c_ext plugin user variables definition */\n"

   271

        base_types = self.GetPlugRoot().GetBaseTypes()

   272

        for var in vars:

   273

            if var["Type"] in base_types:

   274

                prefix = "IEC_"

   275

            else:

   276

                prefix = ""

   277

            text += "%s%s beremiz%s;\n"%(prefix, var["Type"], var["location"])

   278

            text += "%s%s *%s = &beremiz%s;\n"%(prefix, var["Type"], var["location"], var["location"])

   279

        text += "/* User variables reference */\n"

   280

        for var in vars:

   281

            text += "#define %s beremiz%s\n"%(var["Name"], var["location"])

   282

        text += "\n"

   283

   284

        # Adding user global variables and routines

   285

        text += "/* User internal user variables and routines */\n"

   286

        text += self.CFile.globals.gettext()

   287

   288

        # Adding Beremiz plugin functions

   289

        text += "/* Beremiz plugin functions */\n"

   290

        text += "int __init_%s(int argc,char **argv)\n{\n"%location_str

   291

        text += self.CFile.initFunction.gettext()

   292

        text += "  return 0;\n"

   293

        text += "\n}\n\n"

   294

   295

        text += "void __cleanup_%s()\n{\n"%location_str

   296

        text += self.CFile.cleanUpFunction.gettext()

   297

        text += "\n}\n\n"

   298

   299

        text += "void __retrieve_%s()\n{\n"%location_str

   300

        text += self.CFile.retrieveFunction.gettext()

   301

        text += "\n}\n\n"

   302

   303

        text += "void __publish_%s()\n{\n"%location_str

   304

        text += self.CFile.publishFunction.gettext()

   305

        text += "\n}\n\n"

   306

   307

        Gen_Cfile_path = os.path.join(buildpath, "CFile_%s.c"%location_str)

   308

        cfile = open(Gen_Cfile_path,'w')

   309

        cfile.write(text)

   310

        cfile.close()

   311

   312

        if wx.Platform == '__WXMSW__':

   313

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

   314

        else:

   315

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

   316

   317

        return [(Gen_Cfile_path, str(self.CExtension.getCFLAGS() + matiec_flags))],str(self.CExtension.getLDFLAGS()),True

   318

   319

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

   320

#                      Current Buffering Management Functions

   321

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

   322

   323

    """

   324

    Return a copy of the project

   325

    """

   326

    def Copy(self, model):

   327

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

   328

   329

    def BufferCFile(self):

   330

        self.CFileBuffer.Buffering(self.Copy(self.CFile))

   331

   332

    def StartBuffering(self):

   333

        self.CFileBuffer.Buffering(self.CFile)

   334

        self.Buffering = True

   335

   336

    def EndBuffering(self):

   337

        if self.Buffering:

   338

            self.CFile = self.Copy(self.CFile)

   339

            self.Buffering = False

   340

   341

    def CFileIsSaved(self):

   342

        if self.CFileBuffer:

   343

            return self.CFileBuffer.IsCurrentSaved()

   344

        else:

   345

            return True

   346

   347

    def LoadPrevious(self):

   348

        self.CFile = self.Copy(self.CFileBuffer.Previous())

   349

   350

    def LoadNext(self):

   351

        self.CFile = self.Copy(self.CFileBuffer.Next())

   352

   353

    def GetBufferState(self):

   354

        first = self.CFileBuffer.IsFirst()

   355

        last = self.CFileBuffer.IsLast()

   356

        return not first, not last

   357

   358

class RootClass:

   359

   360

    PlugChildsTypes = [("C_File",_Cfile, "C file")]

   361

   362

    def PlugGenerate_C(self, buildpath, locations):

   363

        return [],"",False

   364

   365