1

"""

     2

Base definitions for beremiz plugins

     3

"""

     4

     5

import os,sys

     6

import plugins

     7

import types

     8

import shutil

     9

from xml.dom import minidom

    10

import wx

    11

    12

#Quick hack to be able to find Beremiz IEC tools. Should be config params.

    13

base_folder = os.path.split(sys.path[0])[0]

    14

sys.path.append(os.path.join(base_folder, "plcopeneditor"))

    15

    16

from xmlclass import GenerateClassesFromXSDstring

    17

    18

_BaseParamsClass = GenerateClassesFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>

    19

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

    20

          <xsd:element name="BaseParams">

    21

            <xsd:complexType>

    22

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

    23

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

    24

              <xsd:attribute name="Enabled" type="xsd:boolean" use="required" default="true"/>

    25

            </xsd:complexType>

    26

          </xsd:element>

    27

        </xsd:schema>""")[0]["BaseParams"]

    28

    29

NameTypeSeparator = '@'

    30

    31

class PlugTemplate:

    32

    """

    33

    This class is the one that define plugins.

    34

    """

    35

    36

    XSD = None

    37

    PlugChildsTypes = []

    38

    PlugMaxCount = None

    39

    PluginMethods = []

    40

    41

    def _AddParamsMembers(self):

    42

        Classes = GenerateClassesFromXSDstring(self.XSD)[0]

    43

        self.PlugParams = None

    44

        Classes = [(name, XSDclass) for name, XSDclass in Classes.items() if XSDclass.IsBaseClass]

    45

        if len(Classes) == 1:

    46

            name, XSDclass = Classes[0]

    47

            obj = XSDclass()

    48

            self.PlugParams = (name, obj)

    49

            setattr(self, name, obj)

    50

    51

    def __init__(self):

    52

        # Create BaseParam 

    53

        self.BaseParams = _BaseParamsClass()

    54

        self.MandatoryParams = ("BaseParams", self.BaseParams)

    55

        self._AddParamsMembers()

    56

        self.PluggedChilds = {}

    57

    58

    def PluginBaseXmlFilePath(self, PlugName=None):

    59

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

    60

    61

    def PluginXmlFilePath(self, PlugName=None):

    62

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

    63

    64

    def PlugPath(self,PlugName=None):

    65

        if not PlugName:

    66

            PlugName = self.BaseParams.getName()

    67

        return os.path.join(self.PlugParent.PlugPath(), PlugName + NameTypeSeparator + self.PlugType)

    68

    69

    def PlugTestModified(self):

    70

        return False

    71

    72

    def OnPlugSave(self):

    73

        #Default, do nothing and return success

    74

        return True

    75

    76

    def GetParamsAttributes(self, path = None):

    77

        if path:

    78

            parts = path.split(".", 1)

    79

            if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

    80

                return self.MandatoryParams[1].getElementInfos(parts[0], parts[1])

    81

            elif self.PlugParams and parts[0] == self.PlugParams[0]:

    82

                return self.PlugParams[1].getElementInfos(parts[0], parts[1])

    83

        else:

    84

            params = []

    85

            if self.MandatoryParams:

    86

                params.append(self.MandatoryParams[1].getElementInfos(self.MandatoryParams[0]))

    87

            if self.PlugParams:

    88

                params.append(self.PlugParams[1].getElementInfos(self.PlugParams[0]))

    89

            return params

    90

    91

    def SetParamsAttribute(self, path, value):

    92

        parts = path.split(".", 1)

    93

        if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

    94

            self.MandatoryParams[1].setElementValue(parts[1], value)

    95

        elif self.PlugParams and parts[0] == self.PlugParams[0]:

    96

            self.PlugParams[1].setElementValue(parts[1], value)

    97

    98

    def PlugRequestSave(self):

    99

        # If plugin do not have corresponding directory

   100

        plugpath = self.PlugPath()

   101

        if not os.path.isdir(plugpath):

   102

            # Create it

   103

            os.mkdir(plugpath)

   104

   105

        # generate XML for base XML parameters controller of the plugin

   106

        if self.MandatoryParams:

   107

            BaseXMLFile = open(self.PluginBaseXmlFilePath(),'w')

   108

            BaseXMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

   109

            BaseXMLFile.write(self.MandatoryParams[1].generateXMLText(self.MandatoryParams[0], 0))

   110

            BaseXMLFile.close()

   111

   112

        # generate XML for XML parameters controller of the plugin

   113

        if self.PlugParams:

   114

            XMLFile = open(self.PluginXmlFilePath(),'w')

   115

            XMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

   116

            XMLFile.write(self.PlugParams[1].generateXMLText(self.PlugParams[0], 0))

   117

            XMLFile.close()

   118

   119

        # Call the plugin specific OnPlugSave method

   120

        result = self.OnPlugSave()

   121

        if not result:

   122

            return "Error while saving \"%s\""%self.PlugPath()

   123

   124

        # go through all childs and do the same

   125

        for PlugChild in self.IterChilds():

   126

            result = PlugChild.PlugRequestSave()

   127

            if result:

   128

                return result

   129

        return None

   130

   131

    def PlugImport(self, src_PlugPath):

   132

        shutil.copytree(src_PlugPath, self.PlugPath)

   133

        return True

   134

   135

    def PlugGenerate_C(self, buildpath, current_location, locations, logger):

   136

        """

   137

        Generate C code

   138

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

   139

        @param locations: List of complete variables locations \

   140

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

   141

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

   142

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

   143

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

   144

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

   145

            }, ...]

   146

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

   147

        """

   148

        logger.write_warning(".".join(map(lambda x:str(x), current_location)) + " -> Nothing yo do\n")

   149

        return [],""

   150

   151

    def _Generate_C(self, buildpath, current_location, locations, logger):

   152

        # Generate plugins [(Cfiles, CFLAGS)], LDFLAGS

   153

        PlugCFilesAndCFLAGS, PlugLDFLAGS = self.PlugGenerate_C(buildpath, current_location, locations, logger)

   154

        # recurse through all childs, and stack their results

   155

        for PlugChild in self.IterChilds():

   156

            # Compute child's IEC location

   162

            # Get childs [(Cfiles, CFLAGS)], LDFLAGS

   163

            CFilesAndCFLAGS, LDFLAGS = \

   164

                PlugChild._Generate_C(

   165

                    #keep the same path

   166

                    buildpath,

   167

                    # but update location (add curent IEC channel at the end)

   168

                    new_location,

   169

                    # filter locations that start with current IEC location

   170

                    [loc for loc in locations if loc["LOC"][0:len(new_location)] == new_location ],

   171

                    #propagete logger

   172

                    logger)

   173

            # stack the result

   174

            PlugCFilesAndCFLAGS += CFilesAndCFLAGS

   175

            PlugLDFLAGS += LDFLAGS

   176

   177

        return PlugCFilesAndCFLAGS,PlugLDFLAGS

   178

   179

    def BlockTypesFactory(self):

   180

        return []

   181

   182

    def STLibraryFactory(self):

   183

        return ""

   184

   185

    def IterChilds(self):

   186

        for PlugType, PluggedChilds in self.PluggedChilds.items():

   187

            for PlugInstance in PluggedChilds:

   188

                   yield PlugInstance

   189

   190

    def _GetChildBySomething(self, sep, something, matching):

   191

        toks = matching.split(sep,1)

   192

        for PlugInstance in self.IterChilds():

   193

            # if match component of the name

   194

            if getattr(PlugInstance.BaseParams, something) == toks[0]:

   195

                # if Name have other components

   196

                if len(toks) == 2:

   197

                    # Recurse in order to find the latest object

   198

                    return PlugInstance._GetChildBySomething( sep, something, toks[1])

   199

                # No sub name -> found

   200

                return PlugInstance

   201

        # Not found

   202

        return None

   203

   204

    def GetChildByName(self, Name):

   205

        return self._GetChildBySomething('.',"Name", Name)

   206

   207

    def GetChildByIECLocation(self, Location):

   208

        return self._GetChildBySomething('_',"IEC_Channel", Name)

   209

   216

    def GetPlugInfos(self):

   217

        childs = []

   218

        for child in self.IterChilds():

   219

            childs.append(child.GetPlugInfos())

   220

        return {"name" : self.BaseParams.getName(), "type" : None, "values" : childs}

   221

   222

    def FindNewIEC_Channel(self, DesiredChannel):

   223

        """

   224

        Changes IEC Channel number to DesiredChannel if available, nearest available if not.

   225

        @param DesiredChannel: The desired IEC channel (int)

   226

        """

   227

        # Get Current IEC channel

   228

        CurrentChannel = self.BaseParams.getIEC_Channel()

   229

        # Do nothing if no change

   230

        if CurrentChannel == DesiredChannel: return CurrentChannel

   231

        # Build a list of used Channels out of parent's PluggedChilds

   232

        AllChannels=[]

   233

        for PlugInstance in self.PlugParent.IterChilds():

   234

            if PlugInstance != self:

   235

                AllChannels.append(PlugInstance.BaseParams.getIEC_Channel())

   236

        AllChannels.sort()

   237

   238

        # Now, try to guess the nearest available channel

   239

        res = DesiredChannel

   240

        while res in AllChannels: # While channel not free

   241

            if res < CurrentChannel: # Want to go down ?

   242

                res -=  1 # Test for n-1

   243

                if res < 0 : return CurrentChannel # Can't go bellow 0, do nothing

   244

            else : # Want to go up ?

   245

                res +=  1 # Test for n-1

   246

        # Finally set IEC Channel

   247

        self.BaseParams.setIEC_Channel(res)

   248

        return res

   249

   250

    def OnPlugClose(self):

   251

        return True

   252

   253

    def _doRemoveChild(self, PlugInstance):

   254

        # Remove all childs of child

   255

        for SubPlugInstance in PlugInstance.IterChilds():

   256

            PlugInstance._doRemoveChild(SubPlugInstance)

   257

        # Call the OnCloseMethod

   258

        PlugInstance.OnPlugClose()

   259

        # Delete plugin dir

   260

        shutil.rmtree(PlugInstance.PlugPath())

   261

        # Remove child of PluggedChilds

   262

        self.PluggedChilds[PlugInstance.PlugType].remove(PlugInstance)

   263

        # Forget it... (View have to refresh)

   264

   265

    def PlugRemoveChild(self, PlugName):

   266

        # Fetch the plugin

   267

        PlugInstance = self.GetChildByName(PlugName)

   268

        # Ask to his parent to remove it

   269

        PlugInstance.PlugParent._doRemoveChild(PlugInstance)

   270

   271

    def PlugAddChild(self, PlugName, PlugType):

   272

        """

   273

        Create the plugins that may be added as child to this node self

   274

        @param PlugType: string desining the plugin class name (get name from PlugChildsTypes)

   275

        @param PlugName: string for the name of the plugin instance

   276

        """

   277

        PlugChildsTypes = dict(self.PlugChildsTypes)

   278

        # Check that adding this plugin is allowed

   279

        try:

   280

            PlugClass = PlugChildsTypes[PlugType]

   281

        except KeyError:

   282

            raise Exception, "Cannot create child %s of type %s "%(PlugName, PlugType)

   283

   284

        # if PlugClass is a class factory, call it. (prevent unneeded imports)

   285

        if type(PlugClass) == types.FunctionType:

   286

            PlugClass = PlugClass()

   287

   288

        # Eventualy Initialize child instance list for this class of plugin

   289

        PluggedChildsWithSameClass = self.PluggedChilds.setdefault(PlugType, list())

   290

        # Check count

   291

        if getattr(PlugClass, "PlugMaxCount", None) and len(PluggedChildsWithSameClass) >= PlugClass.PlugMaxCount:

   292

            raise Exception, "Max count (%d) reached for this plugin of type %s "%(PlugClass.PlugMaxCount, PlugType)

   293

   294

        # create the final class, derived of provided plugin and template

   295

        class FinalPlugClass(PlugClass, PlugTemplate):

   296

            """

   297

            Plugin class is derivated into FinalPlugClass before being instanciated

   298

            This way __init__ is overloaded to ensure PlugTemplate.__init__ is called 

   299

            before PlugClass.__init__, and to do the file related stuff.

   300

            """

   301

            def __init__(_self):

   302

                # self is the parent

   303

                _self.PlugParent = self

   304

                # Keep track of the plugin type name

   305

                _self.PlugType = PlugType

   306

                # Call the base plugin template init - change XSD into class members

   307

                PlugTemplate.__init__(_self)

   308

                # If dir have already be made, and file exist

   309

                if os.path.isdir(_self.PlugPath(PlugName)) and os.path.isfile(_self.PluginXmlFilePath(PlugName)):

   310

                    #Load the plugin.xml file into parameters members

   311

                    _self.LoadXMLParams(PlugName)

   312

                    # Basic check. Better to fail immediately.

   313

                    if (_self.BaseParams.getName() != PlugName):

   314

                        raise Exception, "Project tree layout do not match plugin.xml %s!=%s "%(PlugName, _self.BaseParams.getName())

   315

   316

                    # Now, self.PlugPath() should be OK

   317

   318

                    # Check that IEC_Channel is not already in use.

   319

                    _self.FindNewIEC_Channel(_self.BaseParams.getIEC_Channel())

   320

                    # Call the plugin real __init__

   321

                    if getattr(PlugClass, "__init__", None):

   322

                        PlugClass.__init__(_self)

   323

                    #Load and init all the childs

   324

                    _self.LoadChilds()

   325

                else:

   326

                    # If plugin do not have corresponding file/dirs - they will be created on Save

   327

                    # Set plugin name

   328

                    _self.BaseParams.setName(PlugName)

   329

                    os.mkdir(_self.PlugPath())

   330

                    # Find an IEC number

   331

                    _self.FindNewIEC_Channel(0)

   332

                    # Call the plugin real __init__

   333

                    if getattr(PlugClass, "__init__", None):

   334

                        PlugClass.__init__(_self)

   335

                    _self.PlugRequestSave()

   336

   337

        # Create the object out of the resulting class

   338

        newPluginOpj = FinalPlugClass()

   339

        # Store it in PluggedChils

   340

        PluggedChildsWithSameClass.append(newPluginOpj)

   341

   342

        return newPluginOpj

   343

   344

   345

    def LoadXMLParams(self, PlugName = None):

   346

        # Get the base xml tree

   347

        if self.MandatoryParams:

   348

            basexmlfile = open(self.PluginBaseXmlFilePath(PlugName), 'r')

   349

            basetree = minidom.parse(basexmlfile)

   350

            self.MandatoryParams[1].loadXMLTree(basetree.childNodes[0])

   351

            basexmlfile.close()

   352

   353

        # Get the xml tree

   354

        if self.PlugParams:

   355

            xmlfile = open(self.PluginXmlFilePath(PlugName), 'r')

   356

            tree = minidom.parse(xmlfile)

   357

            self.PlugParams[1].loadXMLTree(tree.childNodes[0])

   358

            xmlfile.close()

   359

   360

    def LoadChilds(self):

   361

        # Iterate over all PlugName@PlugType in plugin directory, and try to open them

   362

        for PlugDir in os.listdir(self.PlugPath()):

   363

            if os.path.isdir(os.path.join(self.PlugPath(), PlugDir)) and \

   364

               PlugDir.count(NameTypeSeparator) == 1:

   369

   370

def _GetClassFunction(name):

   371

    def GetRootClass():

   372

        return getattr(__import__("plugins." + name), name).RootClass

   373

    return GetRootClass

   374

   375

   376

####################################################################################

   377

####################################################################################

   378

####################################################################################

   379

###################################   ROOT    ######################################

   380

####################################################################################

   381

####################################################################################

   382

####################################################################################

   383

   384

iec2cc_path = os.path.join(base_folder, "matiec", "iec2cc")

   385

ieclib_path = os.path.join(base_folder, "matiec", "lib")

   386

   387

# import for project creation timestamping

   388

from time import localtime

   389

from datetime import datetime

   390

# import necessary stuff from PLCOpenEditor

   391

from PLCControler import PLCControler

   392

from PLCOpenEditor import PLCOpenEditor, ProjectDialog

   393

from TextViewer import TextViewer

   394

from plcopen.structures import IEC_KEYWORDS

   395

import re

   396

   397

class PluginsRoot(PlugTemplate):

   398

    """

   399

    This class define Root object of the plugin tree. 

   400

    It is responsible of :

   401

    - Managing project directory

   402

    - Building project

   403

    - Handling PLCOpenEditor controler and view

   404

    - Loading user plugins and instanciante them as childs

   405

    - ...

   406

   407

    """

   408

   409

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

   410

    PlugChildsTypes = [(name, _GetClassFunction(name)) for name in plugins.__all__]

   411

   412

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

   413

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

   414

      <xsd:simpleType name="Win32Compiler">

   415

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

   416

          <xsd:enumeration value="Cygwin"/>

   417

          <xsd:enumeration value="MinGW"/>

   418

          <xsd:enumeration value="VC++"/>

   419

        </xsd:restriction>

   420

      </xsd:simpleType>

   421

      <xsd:element name="BeremizRoot">

   422

        <xsd:complexType>

   423

          <xsd:element name="TargetType">

   424

            <xsd:complexType>

   425

              <xsd:choice>

   426

                <xsd:element name="Win32">

   427

                  <xsd:complexType>

   428

                    <xsd:attribute name="ToolChain" type="ppx:Win32Compiler" use="required" default="MinGW"/>

   429

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

   430

                  </xsd:complexType>

   431

                </xsd:element>

   432

                <xsd:element name="Linux">

   433

                  <xsd:complexType>

   434

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

   435

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

   436

                  </xsd:complexType>

   437

                </xsd:element>

   438

                <xsd:element name="Xenomai">

   439

                  <xsd:complexType>

   440

                    <xsd:attribute name="xeno-config" type="xsd:string" use="required" default="/usr/xenomai/"/>

   441

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

   442

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

   443

                  </xsd:complexType>

   444

                </xsd:element>

   445

                <xsd:element name="RTAI">

   446

                  <xsd:complexType>

   447

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

   448

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

   449

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

   450

                  </xsd:complexType>

   451

                </xsd:element>

   452

                <xsd:element name="Library">

   453

                  <xsd:complexType>

   454

                    <xsd:attribute name="Dynamic" type="xsd:boolean" use="required" default="true"/>

   455

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

   456

                  </xsd:complexType>

   457

                </xsd:element>

   458

              </xsd:choice>

   459

            </xsd:complexType>

   460

          </xsd:element>

   461

        </xsd:complexType>

   462

      </xsd:element>

   463

    </xsd:schema>

   464

    """

   465

   466

    def __init__(self, frame):

   467

   468

        self.MandatoryParams = None

   469

        self.AppFrame = frame

   470

   471

        """

   472

        This method are not called here... but in NewProject and OpenProject

   473

        self._AddParamsMembers()

   474

        self.PluggedChilds = {}

   475

        """

   476

   478

        self.PlugParent = None

   479

        # Keep track of the plugin type name

   480

        self.PlugType = "Beremiz"

   481

   482

        # After __init__ root plugin is not valid

   483

        self.ProjectPath = None

   484

        self.PLCManager = None

   485

        self.PLCEditor = None

   486

   487

    def HasProjectOpened(self):

   488

        """

   489

        Return if a project is actually opened

   490

        """

   491

        return self.ProjectPath != None