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

    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 \

   146

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

   147

        """

   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

   157

            new_location = current_location + (self.BaseParams.getIEC_Channel())

   158

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

   159

            CFilesAndCFLAGS, LDFLAGS = \

   160

                PlugChild._Generate_C(

   161

                    #keep the same path

   162

                    buildpath,

   163

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

   164

                    new_location,

   165

                    # filter locations that start with current IEC location

   167

                    #propagete logger

   168

                    logger)

   169

            # stack the result

   170

            PlugCFilesAndCFLAGS += CFilesAndCFLAGS

   171

            PlugLDFLAGS += LDFLAGS

   172

   173

        return PlugCFilesAndCFLAGS,PlugLDFLAGS

   174

   175

    def BlockTypesFactory(self):

   176

        return []

   177

   178

    def STLibraryFactory(self):

   179

        return ""

   180

   181

    def IterChilds(self):

   182

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

   183

            for PlugInstance in PluggedChilds:

   184

                   yield PlugInstance

   185

   186

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

   187

        toks = matching.split(sep,1)

   188

        for PlugInstance in self.IterChilds():

   189

            # if match component of the name

   190

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

   191

                # if Name have other components

   192

                if len(toks) == 2:

   193

                    # Recurse in order to find the latest object

   194

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

   195

                # No sub name -> found

   196

                return PlugInstance

   197

        # Not found

   198

        return None

   199

   200

    def GetChildByName(self, Name):

   201

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

   202

   203

    def GetChildByIECLocation(self, Location):

   204

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

   205

   206

    def GetPlugInfos(self):

   207

        childs = []

   208

        for child in self.IterChilds():

   209

            childs.append(child.GetPlugInfos())

   210

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

   211

   212

    def FindNewIEC_Channel(self, DesiredChannel):

   213

        """

   214

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

   215

        @param DesiredChannel: The desired IEC channel (int)

   216

        """

   217

        # Get Current IEC channel

   218

        CurrentChannel = self.BaseParams.getIEC_Channel()

   219

        # Do nothing if no change

   220

        if CurrentChannel == DesiredChannel: return CurrentChannel

   221

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

   222

        AllChannels=[]

   223

        for PlugInstance in self.PlugParent.IterChilds():

   224

            if PlugInstance != self:

   225

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

   226

        AllChannels.sort()

   227

   228

        # Now, try to guess the nearest available channel

   229

        res = DesiredChannel

   230

        while res in AllChannels: # While channel not free

   231

            if res < CurrentChannel: # Want to go down ?

   232

                res -=  1 # Test for n-1

   233

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

   234

            else : # Want to go up ?

   235

                res +=  1 # Test for n-1

   236

        # Finally set IEC Channel

   237

        self.BaseParams.setIEC_Channel(res)

   238

        return res

   239

   240

    def OnPlugClose(self):

   241

        return True

   242

   243

    def _doRemoveChild(self, PlugInstance):

   244

        # Remove all childs of child

   245

        for SubPlugInstance in PlugInstance.IterChilds():

   246

            PlugInstance._doRemoveChild(SubPlugInstance)

   247

        # Call the OnCloseMethod

   248

        PlugInstance.OnPlugClose()

   249

        # Delete plugin dir

   250

        shutil.rmtree(PlugInstance.PlugPath())

   251

        # Remove child of PluggedChilds

   252

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

   253

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

   254

   255

    def PlugRemoveChild(self, PlugName):

   256

        # Fetch the plugin

   257

        PlugInstance = self.GetChildByName(PlugName)

   258

        # Ask to his parent to remove it

   259

        PlugInstance.PlugParent._doRemoveChild(PlugInstance)

   260

   261

    def PlugAddChild(self, PlugName, PlugType):

   262

        """

   263

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

   264

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

   265

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

   266

        """

   267

        PlugChildsTypes = dict(self.PlugChildsTypes)

   268

        # Check that adding this plugin is allowed

   269

        try:

   270

            PlugClass = PlugChildsTypes[PlugType]

   271

        except KeyError:

   272

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

   273

   274

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

   275

        if type(PlugClass) == types.FunctionType:

   276

            PlugClass = PlugClass()

   277

   278

        # Eventualy Initialize child instance list for this class of plugin

   279

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

   280

        # Check count

   281

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

   282

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

   283

   284

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

   285

        class FinalPlugClass(PlugClass, PlugTemplate):

   286

            """

   287

            Plugin class is derivated into FinalPlugClass before being instanciated

   288

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

   289

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

   290

            """

   291

            def __init__(_self):

   292

                # self is the parent

   293

                _self.PlugParent = self

   294

                # Keep track of the plugin type name

   295

                _self.PlugType = PlugType

   296

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

   297

                PlugTemplate.__init__(_self)

   298

                # If dir have already be made, and file exist

   299

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

   300

                    #Load the plugin.xml file into parameters members

   301

                    _self.LoadXMLParams(PlugName)

   302

                    # Basic check. Better to fail immediately.

   303

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

   304

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

   305

   306

                    # Now, self.PlugPath() should be OK

   307

   308

                    # Check that IEC_Channel is not already in use.

   309

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

   310

                    # Call the plugin real __init__

   311

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

   312

                        PlugClass.__init__(_self)

   313

                    #Load and init all the childs

   314

                    _self.LoadChilds()

   315

                else:

   316

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

   317

                    # Set plugin name

   318

                    _self.BaseParams.setName(PlugName)

   319

                    os.mkdir(_self.PlugPath())

   320

                    # Find an IEC number

   321

                    _self.FindNewIEC_Channel(0)

   322

                    # Call the plugin real __init__

   323

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

   324

                        PlugClass.__init__(_self)

   325

                    _self.PlugRequestSave()

   326

   327

        # Create the object out of the resulting class

   328

        newPluginOpj = FinalPlugClass()

   329

        # Store it in PluggedChils

   330

        PluggedChildsWithSameClass.append(newPluginOpj)

   331

   332

        return newPluginOpj

   333

   334

   335

    def LoadXMLParams(self, PlugName = None):

   336

        # Get the base xml tree

   337

        if self.MandatoryParams:

   338

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

   339

            basetree = minidom.parse(basexmlfile)

   340

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

   341

            basexmlfile.close()

   342

   343

        # Get the xml tree

   344

        if self.PlugParams:

   345

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

   346

            tree = minidom.parse(xmlfile)

   347

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

   348

            xmlfile.close()

   349

   350

    def LoadChilds(self):

   351

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

   352

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

   353

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

   354

               PlugDir.count(NameTypeSeparator) == 1:

   355

                try:

   356

                    self.PlugAddChild(*PlugDir.split(NameTypeSeparator))

   357

                except Exception, e:

   358

                    print e

   359

   360

def _GetClassFunction(name):

   361

    def GetRootClass():

   362

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

   363

    return GetRootClass

   364

   365

   366

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

   367

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

   368

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

   369

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

   370

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

   371

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

   372

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

   373

   374

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

   375

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

   376

   377

# import for project creation timestamping

   378

from time import localtime

   379

from datetime import datetime

   380

# import necessary stuff from PLCOpenEditor

   381

from PLCControler import PLCControler

   382

from PLCOpenEditor import PLCOpenEditor, ProjectDialog

   383

from TextViewer import TextViewer

   384

from plcopen.structures import IEC_KEYWORDS

   386

   387

class PluginsRoot(PlugTemplate):

   388

    """

   389

    This class define Root object of the plugin tree. 

   390

    It is responsible of :

   391

    - Managing project directory

   392

    - Building project

   393

    - Handling PLCOpenEditor controler and view

   394

    - Loading user plugins and instanciante them as childs

   395

    - ...

   396

   397

    """

   398

   399

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

   400

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

   401

   402

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

   403

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

   404

      <xsd:simpleType name="Win32Compiler">

   405

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

   406

          <xsd:enumeration value="Cygwin"/>

   407

          <xsd:enumeration value="MinGW"/>

   408

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

   409

        </xsd:restriction>

   410

      </xsd:simpleType>

   411

      <xsd:element name="BeremizRoot">

   412

        <xsd:complexType>

   413

          <xsd:element name="TargetType">

   414

            <xsd:complexType>

   415

              <xsd:choice>

   416

                <xsd:element name="Win32">

   417

                  <xsd:complexType>

   418

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

   419

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

   420

                  </xsd:complexType>

   421

                </xsd:element>

   422

                <xsd:element name="Linux">

   423

                  <xsd:complexType>

   424

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

   425

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

   426

                  </xsd:complexType>

   427

                </xsd:element>

   428

                <xsd:element name="Xenomai">

   429

                  <xsd:complexType>

   430

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

   431

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

   432

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

   433

                  </xsd:complexType>

   434

                </xsd:element>

   435

                <xsd:element name="RTAI">

   436

                  <xsd:complexType>

   437

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

   438

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

   439

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

   440

                  </xsd:complexType>

   441

                </xsd:element>

   442

                <xsd:element name="Library">

   443

                  <xsd:complexType>

   444

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

   445

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

   446

                  </xsd:complexType>

   447

                </xsd:element>

   448

              </xsd:choice>

   449

            </xsd:complexType>

   450

          </xsd:element>

   451

        </xsd:complexType>

   452

      </xsd:element>

   453

    </xsd:schema>

   454

    """

   455

   456

    def __init__(self, frame):

   457

   458

        self.MandatoryParams = None

   459

        self.AppFrame = frame

   460

   461

        """

   462

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

   463

        self._AddParamsMembers()

   464

        self.PluggedChilds = {}

   465

        """

   466

   467

        # self is the parent

   468

        self.PlugParent = None

   469

        # Keep track of the plugin type name

   470

        self.PlugType = "Beremiz"

   471

   472

        # After __init__ root plugin is not valid

   473

        self.ProjectPath = None

   474

        self.PLCManager = None

   475

        self.PLCEditor = None

   476

   477

    def HasProjectOpened(self):

   478

        """

   479

        Return if a project is actually opened

   480

        """

   481

        return self.ProjectPath != None

   482

   483

    def GetProjectPath(self):

   484

        return self.ProjectPath

   485

   486

    def GetPlugInfos(self):

   487

        childs = []

   488

        for child in self.IterChilds():

   489

            childs.append(child.GetPlugInfos())

   490

        return {"name" : os.path.split(self.ProjectPath)[1], "type" : None, "values" : childs}

   491

   492

    def NewProject(self, ProjectPath):