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" default="__unnamed__"/>

    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

        self.PlugParams = None

    43

        if self.XSD:

    44

            Classes = GenerateClassesFromXSDstring(self.XSD)[0]

    45

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

    46

            if len(Classes) == 1:

    47

                name, XSDclass = Classes[0]

    48

                obj = XSDclass()

    49

                self.PlugParams = (name, obj)

    50

                setattr(self, name, obj)

    51

    52

    def __init__(self):

    53

        # Create BaseParam 

    54

        self.BaseParams = _BaseParamsClass()

    55

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

    56

        self._AddParamsMembers()

    57

        self.PluggedChilds = {}

    58

    59

    def PluginBaseXmlFilePath(self, PlugName=None):

    60

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

    61

    62

    def PluginXmlFilePath(self, PlugName=None):

    63

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

    64

    65

    def PlugPath(self,PlugName=None):

    66

        if not PlugName:

    67

            PlugName = self.BaseParams.getName()

    68

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

    69

    70

    def PlugTestModified(self):

    71

        return False

    72

    73

    def OnPlugSave(self):

    74

        #Default, do nothing and return success

    75

        return True

    76

    77

    def GetParamsAttributes(self, path = None):

    78

        if path:

    79

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

    80

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

    81

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

    82

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

    83

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

    84

        else:

    85

            params = []

    86

            if self.MandatoryParams:

    87

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

    88

            if self.PlugParams:

    89

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

    90

            return params

    91

    92

    def SetParamsAttribute(self, path, value, logger):

    93

        # Filter IEC_Channel and Name, that have specific behavior

    94

        if path == "BaseParams.IEC_Channel":

    95

            return self.FindNewIEC_Channel(value,logger), False

    96

        elif path == "BaseParams.Name":

    97

            res = self.FindNewName(value,logger)

    98

            self.PlugRequestSave()

    99

            return res, True

   100

   101

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

   102

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

   103

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

   104

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

   105

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

   106

        return value, False

   107

   108

    def PlugRequestSave(self):

   109

        # If plugin do not have corresponding directory

   110

        plugpath = self.PlugPath()

   111

        if not os.path.isdir(plugpath):

   112

            # Create it

   113

            os.mkdir(plugpath)

   114

   115

        # generate XML for base XML parameters controller of the plugin

   116

        if self.MandatoryParams:

   117

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

   118

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

   119

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

   120

            BaseXMLFile.close()

   121

   122

        # generate XML for XML parameters controller of the plugin

   123

        if self.PlugParams:

   124

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

   125

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

   126

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

   127

            XMLFile.close()

   128

   129

        # Call the plugin specific OnPlugSave method

   130

        result = self.OnPlugSave()

   131

        if not result:

   132

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

   133

   134

        # go through all childs and do the same

   135

        for PlugChild in self.IterChilds():

   136

            result = PlugChild.PlugRequestSave()

   137

            if result:

   138

                return result

   139

        return None

   140

   141

    def PlugImport(self, src_PlugPath):

   142

        shutil.copytree(src_PlugPath, self.PlugPath)

   143

        return True

   144

   145

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

   146

        """

   147

        Generate C code

   148

        @param locations: List of complete variables locations \

   149

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

   150

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

   151

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

   152

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

   153

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

   154

            }, ...]

   155

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

   156

        """

   157

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

   158

        return [],""

   159

   160

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

   161

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

   162

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

   163

        # recurse through all childs, and stack their results

   164

        for PlugChild in self.IterChilds():

   165

            new_location = PlugChild.GetCurrentLocation()

   166

            # How deep are we in the tree ?

   167

            depth=len(new_location)

   168

            CFilesAndCFLAGS, LDFLAGS = \

   169

                PlugChild._Generate_C(

   170

                    #keep the same path

   171

                    buildpath,

   172

                    # filter locations that start with current IEC location

   173

                    [loc for loc in locations if loc["LOC"][0:depth] == new_location ],

   174

                    #propagete logger

   175

                    logger)

   176

            # stack the result

   177

            PlugCFilesAndCFLAGS += CFilesAndCFLAGS

   178

            PlugLDFLAGS += LDFLAGS

   179

   180

        return PlugCFilesAndCFLAGS,PlugLDFLAGS

   181

   182

    def BlockTypesFactory(self):

   183

        return []

   184

   185

    def STLibraryFactory(self):

   186

        return ""

   187

   188

    def IterChilds(self):

   189

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

   190

            for PlugInstance in PluggedChilds:

   191

                   yield PlugInstance

   192

   193

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

   194

        toks = matching.split(sep,1)

   195

        for PlugInstance in self.IterChilds():

   196

            # if match component of the name

   197

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

   198

                # if Name have other components

   199

                if len(toks) == 2:

   200

                    # Recurse in order to find the latest object

   201

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

   202

                # No sub name -> found

   203

                return PlugInstance

   204

        # Not found

   205

        return None

   206

   207

    def GetChildByName(self, Name):

   208

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

   209

   210

    def GetChildByIECLocation(self, Location):

   211

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

   212

   213

    def GetCurrentLocation(self):

   214

        """

   215

        @return:  Tupple containing plugin IEC location of current plugin : %I0.0.4.5 => (0,0,4,5)

   216

        """

   217

        return self.PlugParent.GetCurrentLocation() + (self.BaseParams.getIEC_Channel(),)

   218

   219

    def GetPlugRoot(self):

   220

        return self.PlugParent.GetPlugRoot()

   221

   222

    def GetPlugInfos(self):

   223

        childs = []

   224

        for child in self.IterChilds():

   225

            childs.append(child.GetPlugInfos())

   226

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

   227

   228

   229

    def FindNewName(self, DesiredName, logger):

   230

        """

   231

        Changes Name to DesiredName if available, Name-N if not.

   232

        @param DesiredName: The desired Name (string)

   233

        """

   234

        # Get Current Name

   235

        CurrentName = self.BaseParams.getName()

   236

        # Do nothing if no change

   237

        #if CurrentName == DesiredName: return CurrentName

   238

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

   239

        AllNames=[]

   240

        for PlugInstance in self.PlugParent.IterChilds():

   241

            if PlugInstance != self:

   242

                AllNames.append(PlugInstance.BaseParams.getName())

   243

   244

        # Find a free name, eventually appending digit

   245

        res = DesiredName

   246

        suffix = 1

   247

        while res in AllNames:

   248

            res = "%s-%d"%(DesiredName, suffix)

   249

            suffix += 1

   250

   251

        # Get old path

   252

        oldname = self.PlugPath()

   253

        # Check previous plugin existance

   254

        dontexist = self.BaseParams.getName() == "__unnamed__"

   255

        # Set the new name

   256

        self.BaseParams.setName(res)

   257

        # Rename plugin dir if exist

   258

        if not dontexist:

   259

            shutil.move(oldname, self.PlugPath())

   260

        # warn user he has two left hands

   261

        if DesiredName != res:

   262

            logger.write_warning("A child names \"%s\" already exist -> \"%s\"\n"%(DesiredName,res))

   263

        return res

   264

   265

    def FindNewIEC_Channel(self, DesiredChannel, logger):

   266

        """

   267

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

   268

        @param DesiredChannel: The desired IEC channel (int)

   269

        """

   270

        # Get Current IEC channel

   271

        CurrentChannel = self.BaseParams.getIEC_Channel()

   272

        # Do nothing if no change

   273

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   274

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

   275

        AllChannels=[]

   276

        for PlugInstance in self.PlugParent.IterChilds():

   277

            if PlugInstance != self:

   278

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

   279

        AllChannels.sort()

   280

   281

        # Now, try to guess the nearest available channel

   282

        res = DesiredChannel

   283

        while res in AllChannels: # While channel not free

   284

            if res < CurrentChannel: # Want to go down ?

   285

                res -=  1 # Test for n-1

   286

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

   287

            else : # Want to go up ?

   288

                res +=  1 # Test for n-1

   289

        # Finally set IEC Channel

   290

        self.BaseParams.setIEC_Channel(res)

   291

        if logger and DesiredChannel != res:

   292

            logger.write_warning("A child with IEC channel %d already exist -> %d\n"%(DesiredChannel,res))

   293

        return res

   294

   295

    def OnPlugClose(self):

   296

        return True

   297

   298

    def _doRemoveChild(self, PlugInstance):

   299

        # Remove all childs of child

   300

        for SubPlugInstance in PlugInstance.IterChilds():

   301

            PlugInstance._doRemoveChild(SubPlugInstance)

   302

        # Call the OnCloseMethod

   303

        PlugInstance.OnPlugClose()

   304

        # Delete plugin dir

   305

        shutil.rmtree(PlugInstance.PlugPath())

   306

        # Remove child of PluggedChilds

   307

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

   308

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

   309

   310

    def PlugRemoveChild(self, PlugName):

   311

        # Fetch the plugin

   312

        PlugInstance = self.GetChildByName(PlugName)

   313

        # Ask to his parent to remove it

   314

        PlugInstance.PlugParent._doRemoveChild(PlugInstance)

   315

   316

    def PlugAddChild(self, PlugName, PlugType, logger):

   317

        """

   318

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

   319

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

   320

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

   321

        """

   322

        PlugChildsTypes = dict(self.PlugChildsTypes)

   323

        # Check that adding this plugin is allowed

   324

        try:

   325

            PlugClass = PlugChildsTypes[PlugType]

   326

        except KeyError:

   327

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

   328

   329

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

   330

        if type(PlugClass) == types.FunctionType:

   331

            PlugClass = PlugClass()

   332

   333

        # Eventualy Initialize child instance list for this class of plugin

   334

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

   335

        # Check count

   336

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

   337

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

   338

   339

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

   340

        class FinalPlugClass(PlugClass, PlugTemplate):

   341

            """

   342

            Plugin class is derivated into FinalPlugClass before being instanciated

   343

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

   344

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

   345

            """

   346

            def __init__(_self):

   347

                # self is the parent

   348

                _self.PlugParent = self

   349

                # Keep track of the plugin type name

   350

                _self.PlugType = PlugType

   351

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

   352

                PlugTemplate.__init__(_self)

   353

                # check name is unique

   354

                NewPlugName = _self.FindNewName(PlugName, logger)

   355

                # If dir have already be made, and file exist

   356

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

   357

                    #Load the plugin.xml file into parameters members

   358

                    _self.LoadXMLParams(NewPlugName)

   359

                    # Basic check. Better to fail immediately.

   360

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

   361

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

   362

   363

                    # Now, self.PlugPath() should be OK

   364

   365

                    # Check that IEC_Channel is not already in use.

   366

                    _self.FindNewIEC_Channel(_self.BaseParams.getIEC_Channel(),logger)

   367

                    # Call the plugin real __init__

   368

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

   369

                        PlugClass.__init__(_self)

   370

                    #Load and init all the childs

   371

                    _self.LoadChilds(logger)

   372

                else:

   373

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

   374

                    os.mkdir(_self.PlugPath())

   375

                    # Find an IEC number

   376

                    _self.FindNewIEC_Channel(0, None)

   377

                    # Call the plugin real __init__

   378

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

   379

                        PlugClass.__init__(_self)

   380

                    _self.PlugRequestSave()

   381

   382

        # Create the object out of the resulting class

   383

        newPluginOpj = FinalPlugClass()

   384

        # Store it in PluggedChils

   385

        PluggedChildsWithSameClass.append(newPluginOpj)

   386

   387

        return newPluginOpj

   388

   389

   390

    def LoadXMLParams(self, PlugName = None):

   391

        # Get the base xml tree

   392

        if self.MandatoryParams:

   393

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

   394

            basetree = minidom.parse(basexmlfile)

   395

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

   396

            basexmlfile.close()

   397

   398

        # Get the xml tree

   399

        if self.PlugParams:

   400

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

   401

            tree = minidom.parse(xmlfile)

   402

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

   403

            xmlfile.close()

   404

   405

    def LoadChilds(self, logger):

   406

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

   407

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

   408

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

   409

               PlugDir.count(NameTypeSeparator) == 1:

   410

                pname, ptype = PlugDir.split(NameTypeSeparator)

   411

                try:

   412

                    self.PlugAddChild(pname, ptype, logger)

   413

                except Exception, e:

   414

                    logger.write_error("Could not add child \"%s\", type %s :\n%s\n"%(pname, ptype, str(e)))

   415

   416

def _GetClassFunction(name):

   417

    def GetRootClass():

   418

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

   419

    return GetRootClass

   420

   421

   422

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

   423

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

   424

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

   425

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

   426

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

   427

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

   428

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

   429

   430

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

   431

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

   432

   433

# import for project creation timestamping

   434

from time import localtime

   435

from datetime import datetime

   436

# import necessary stuff from PLCOpenEditor

   437

from PLCControler import PLCControler

   438

from PLCOpenEditor import PLCOpenEditor, ProjectDialog

   439

from TextViewer import TextViewer

   440

from plcopen.structures import IEC_KEYWORDS

   441

import re

   442

   443

class PluginsRoot(PlugTemplate):

   444

    """

   445

    This class define Root object of the plugin tree. 

   446

    It is responsible of :

   447

    - Managing project directory

   448

    - Building project

   449

    - Handling PLCOpenEditor controler and view

   450

    - Loading user plugins and instanciante them as childs

   451

    - ...

   452

   453

    """

   454

   455

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

   456

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

   457

   458

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

   459

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

   460

      <xsd:simpleType name="Win32Compiler">

   461

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

   462

          <xsd:enumeration value="Cygwin"/>

   463

          <xsd:enumeration value="MinGW"/>

   464

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

   465

        </xsd:restriction>

   466

      </xsd:simpleType>

   467

      <xsd:element name="BeremizRoot">

   468

        <xsd:complexType>

   469

          <xsd:element name="TargetType">

   470

            <xsd:complexType>

   471

              <xsd:choice>

   472

                <xsd:element name="Win32">

   473

                  <xsd:complexType>

   474

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

   475

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

   476

                  </xsd:complexType>

   477

                </xsd:element>

   478

                <xsd:element name="Linux">

   479

                  <xsd:complexType>

   480

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

   481

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

   482

                  </xsd:complexType>

   483

                </xsd:element>

   484

                <xsd:element name="Xenomai">

   485

                  <xsd:complexType>

   486

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

   487

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

   488

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

   489

                  </xsd:complexType>

   490

                </xsd:element>

   491