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

    23

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

    24

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

    25

            </xsd:complexType>

    26

          </xsd:element>

    27

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

    28

    29

NameTypeSeparator = '@'

    30

    31

class MiniTextControler:

    32

    33

    def __init__(self, filepath):

    34

        self.FilePath = filepath

    35

    36

    def SetEditedElementText(self, tagname, text):

    37

        file = open(self.FilePath, "w")

    38

        file.write(text)

    39

        file.close()

    40

    41

    def GetEditedElementText(self, tagname):

    42

        if os.path.isfile(self.FilePath):

    43

            file = open(self.FilePath, "r")

    44

            text = file.read()

    45

            file.close()

    46

            return text

    47

        return ""

    48

    49

    def GetEditedElementInterfaceVars(self, tagname):

    50

        return []

    51

    52

    def GetEditedElementType(self, tagname):

    53

        return "program"

    54

    55

    def GetBlockTypes(self, tagname = ""):

    56

        return []

    57

    58

    def GetEnumeratedDataValues(self):

    59

        return []

    60

    61

    def StartBuffering(self):

    62

        pass

    63

    64

    def EndBuffering(self):

    65

        pass

    66

    67

    def BufferProject(self):

    68

        pass

    69

    70

class PlugTemplate:

    71

    """

    72

    This class is the one that define plugins.

    73

    """

    74

    75

    XSD = None

    76

    PlugChildsTypes = []

    77

    PlugMaxCount = None

    78

    PluginMethods = []

    79

    80

    def _AddParamsMembers(self):

    81

        self.PlugParams = None

    82

        if self.XSD:

    83

            Classes = GenerateClassesFromXSDstring(self.XSD)

    84

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

    85

            if len(Classes) == 1:

    86

                name, XSDclass = Classes[0]

    87

                obj = XSDclass()

    88

                self.PlugParams = (name, obj)

    89

                setattr(self, name, obj)

    90

    91

    def __init__(self):

    92

        # Create BaseParam 

    93

        self.BaseParams = _BaseParamsClass()

    94

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

    95

        self._AddParamsMembers()

    96

        self.PluggedChilds = {}

    97

    98

    def PluginBaseXmlFilePath(self, PlugName=None):

    99

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

   100

   101

    def PluginXmlFilePath(self, PlugName=None):

   102

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

   103

   104

    def PlugPath(self,PlugName=None):

   105

        if not PlugName:

   106

            PlugName = self.BaseParams.getName()

   107

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

   108

   109

    def PlugTestModified(self):

   110

        return False

   111

   112

    def OnPlugSave(self):

   113

        #Default, do nothing and return success

   114

        return True

   115

   116

    def GetParamsAttributes(self, path = None):

   117

        if path:

   118

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

   119

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

   120

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

   121

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

   122

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

   123

        else:

   124

            params = []

   125

            if wx.VERSION < (2, 8, 0) and self.MandatoryParams:

   126

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

   127

            if self.PlugParams:

   128

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

   129

            return params

   130

   131

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

   132

        # Filter IEC_Channel and Name, that have specific behavior

   133

        if path == "BaseParams.IEC_Channel":

   134

            return self.FindNewIEC_Channel(value,logger), True

   135

        elif path == "BaseParams.Name":

   136

            res = self.FindNewName(value,logger)

   137

            self.PlugRequestSave()

   138

            return res, False

   139

   140

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

   141

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

   142

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

   143

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

   144

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

   145

        return value, False

   146

   147

    def PlugRequestSave(self):

   148

        # If plugin do not have corresponding directory

   149

        plugpath = self.PlugPath()

   150

        if not os.path.isdir(plugpath):

   151

            # Create it

   152

            os.mkdir(plugpath)

   153

   154

        # generate XML for base XML parameters controller of the plugin

   155

        if self.MandatoryParams:

   156

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

   157

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

   158

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

   159

            BaseXMLFile.close()

   160

   161

        # generate XML for XML parameters controller of the plugin

   162

        if self.PlugParams:

   163

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

   164

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

   165

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

   166

            XMLFile.close()

   167

   168

        # Call the plugin specific OnPlugSave method

   169

        result = self.OnPlugSave()

   170

        if not result:

   171

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

   172

   173

        # go through all childs and do the same

   174

        for PlugChild in self.IterChilds():

   175

            result = PlugChild.PlugRequestSave()

   176

            if result:

   177

                return result

   178

        return None

   179

   180

    def PlugImport(self, src_PlugPath):

   181

        shutil.copytree(src_PlugPath, self.PlugPath)

   182

        return True

   183

   184

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

   185

        """

   186

        Generate C code

   187

        @param locations: List of complete variables locations \

   188

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

   189

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

   190

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

   191

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

   192

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

   193

            }, ...]

   194

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

   195

        """

   196

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

   197

        return [],"",False

   198

   199

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

   200

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

   201

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

   202

        # if some files heve been generated put them in the list with their location

   203

        if PlugCFilesAndCFLAGS:

   204

            LocationCFilesAndCFLAGS = [(self.GetCurrentLocation(), PlugCFilesAndCFLAGS, DoCalls)]

   205

        else:

   206

            LocationCFilesAndCFLAGS = []

   207

   208

        # plugin asks some some LDFLAGS

   209

        if PlugLDFLAGS:

   210

            # LDFLAGS can be either string

   211

            if type(PlugLDFLAGS)==type(str()):

   212

                LDFLAGS=[PlugLDFLAGS]

   213

            #or list of strings

   214

            elif type(PlugLDFLAGS)==type(list()):

   215

                LDFLAGS=PlugLDFLAGS[:]

   216

        else:

   217

            LDFLAGS=[]

   218

   219

        # recurse through all childs, and stack their results

   220

        for PlugChild in self.IECSortedChilds():

   221

            new_location = PlugChild.GetCurrentLocation()

   222

            # How deep are we in the tree ?

   223

            depth=len(new_location)

   224

            _LocationCFilesAndCFLAGS, _LDFLAGS = \

   225

                PlugChild._Generate_C(

   226

                    #keep the same path

   227

                    buildpath,

   228

                    # filter locations that start with current IEC location

   229

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

   230

                    #propagete logger

   231

                    logger)

   232

            # stack the result

   233

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   234

            LDFLAGS += _LDFLAGS

   235

   236

        return LocationCFilesAndCFLAGS,LDFLAGS

   237

   238

    def BlockTypesFactory(self):

   239

        return []

   240

   241

    def STLibraryFactory(self):

   242

        return ""

   243

   244

    def IterChilds(self):

   245

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

   246

            for PlugInstance in PluggedChilds:

   247

                   yield PlugInstance

   248

   249

    def IECSortedChilds(self):

   250

        # reorder childs by IEC_channels

   251

        ordered = [(chld.BaseParams.getIEC_Channel(),chld) for chld in self.IterChilds()]

   252

        if ordered:

   253

            ordered.sort()

   254

            return zip(*ordered)[1]

   255

        else:

   256

            return []

   257

   258

    def _GetChildBySomething(self, something, toks):

   259

        for PlugInstance in self.IterChilds():

   260

            # if match component of the name

   261

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

   262

                # if Name have other components

   263

                if len(toks) >= 2:

   264

                    # Recurse in order to find the latest object

   265

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

   266

                # No sub name -> found

   267

                return PlugInstance

   268

        # Not found

   269

        return None

   270

   271

    def GetChildByName(self, Name):

   272

        if Name:

   273

            toks = Name.split('.')

   274

            return self._GetChildBySomething("Name", toks)

   275

        else:

   276

            return self

   277

   278

    def GetChildByIECLocation(self, Location):

   279

        if Location:

   280

            return self._GetChildBySomething("IEC_Channel", Location)

   281

        else:

   282

            return self

   283

   284

    def GetCurrentLocation(self):

   285

        """

   286

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

   287

        """

   288

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

   289

   290

    def GetCurrentName(self):

   291

        """

   292

        @return:  String "ParentParentName.ParentName.Name"

   293

        """

   294

        return  self.PlugParent._GetCurrentName() + self.BaseParams.getName()

   295

   296

    def _GetCurrentName(self):

   297

        """

   298

        @return:  String "ParentParentName.ParentName.Name."

   299

        """

   300

        return  self.PlugParent._GetCurrentName() + self.BaseParams.getName() + "."

   301

   302

    def GetPlugRoot(self):

   303

        return self.PlugParent.GetPlugRoot()

   304

   305

    def GetFullIEC_Channel(self):

   306

        return ".".join([str(i) for i in self.GetCurrentLocation()]) + ".x"

   307

   308

    def GetLocations(self):

   309

        location = self.GetCurrentLocation()

   310

        return [loc for loc in self.PlugParent.GetLocations() if loc["LOC"][0:len(location)] == location]

   311

   312

    def GetPlugInfos(self):

   313

        childs = []

   314

        # reorder childs by IEC_channels

   315

        for child in self.IECSortedChilds():

   316

            childs.append(child.GetPlugInfos())

   317

        if wx.VERSION < (2, 8, 0):

   318

            return {"name" : "%d-%s"%(self.BaseParams.getIEC_Channel(),self.BaseParams.getName()), "type" : self.BaseParams.getName(), "values" : childs}

   319

        else:

   320

            return {"name" : self.BaseParams.getName(), "channel" : self.BaseParams.getIEC_Channel(), "enabled" : self.BaseParams.getEnabled(), "parent" : len(self.PlugChildsTypes) > 0, "type" : self.BaseParams.getName(), "values" : childs}

   321

   322

    def FindNewName(self, DesiredName, logger):

   323

        """

   324

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

   325

        @param DesiredName: The desired Name (string)

   326

        """

   327

        # Get Current Name

   328

        CurrentName = self.BaseParams.getName()

   329

        # Do nothing if no change

   330

        #if CurrentName == DesiredName: return CurrentName

   331

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

   332

        AllNames=[]

   333

        for PlugInstance in self.PlugParent.IterChilds():

   334

            if PlugInstance != self:

   335

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

   336

   337

        # Find a free name, eventually appending digit

   338

        res = DesiredName

   339

        suffix = 1

   340

        while res in AllNames:

   341

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

   342

            suffix += 1

   343

   344

        # Get old path

   345

        oldname = self.PlugPath()

   346

        # Check previous plugin existance

   347

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

   348

        # Set the new name

   349

        self.BaseParams.setName(res)

   350

        # Rename plugin dir if exist

   351

        if not dontexist:

   352

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

   353

        # warn user he has two left hands

   354

        if DesiredName != res:

   355

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

   356

        return res

   357

   358

    def FindNewIEC_Channel(self, DesiredChannel, logger):

   359

        """

   360

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

   361

        @param DesiredChannel: The desired IEC channel (int)

   362

        """

   363

        # Get Current IEC channel

   364

        CurrentChannel = self.BaseParams.getIEC_Channel()

   365

        # Do nothing if no change

   366

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   367

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

   368

        AllChannels=[]

   369

        for PlugInstance in self.PlugParent.IterChilds():

   370

            if PlugInstance != self:

   371

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

   372

        AllChannels.sort()

   373

   374

        # Now, try to guess the nearest available channel

   375

        res = DesiredChannel

   376

        while res in AllChannels: # While channel not free

   377

            if res < CurrentChannel: # Want to go down ?

   378

                res -=  1 # Test for n-1

   379

                if res < 0 :

   380

                    if logger :

   381

                        logger.write_warning("Cannot find lower free IEC channel than %d\n"%CurrentChannel)

   382

                    return CurrentChannel # Can't go bellow 0, do nothing

   383

            else : # Want to go up ?

   384

                res +=  1 # Test for n-1

   385

        # Finally set IEC Channel

   386

        self.BaseParams.setIEC_Channel(res)

   387

        if logger and DesiredChannel != res:

   388

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

   389

        return res

   390

   391

    def OnPlugClose(self):

   392

        return True

   393

   394

    def _doRemoveChild(self, PlugInstance):

   395

        # Remove all childs of child

   396

        for SubPlugInstance in PlugInstance.IterChilds():

   397

            PlugInstance._doRemoveChild(SubPlugInstance)

   398

        # Call the OnCloseMethod

   399

        PlugInstance.OnPlugClose()

   400

        # Delete plugin dir

   401

        shutil.rmtree(PlugInstance.PlugPath())

   402

        # Remove child of PluggedChilds

   403

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

   404

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

   405

   406

    def PlugRemove(self):

   407

        # Fetch the plugin

   408

        #PlugInstance = self.GetChildByName(PlugName)

   409

        # Ask to his parent to remove it

   410

        self.PlugParent._doRemoveChild(self)

   411

   412

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

   413

        """

   414

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

   415

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

   416

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

   417

        """

   418

        PlugChildsTypes = dict(self.PlugChildsTypes)

   419

        # Check that adding this plugin is allowed

   420

        try:

   421

            PlugClass = PlugChildsTypes[PlugType]

   422

        except KeyError:

   423

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

   424

   425

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

   426

        if type(PlugClass) == types.FunctionType:

   427

            PlugClass = PlugClass()

   428

   429

        # Eventualy Initialize child instance list for this class of plugin

   430

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

   431

        # Check count

   432

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

   433

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

   434

   435

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

   436

        class FinalPlugClass(PlugClass, PlugTemplate):

   437

            """

   438

            Plugin class is derivated into FinalPlugClass before being instanciated

   439

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

   440

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

   441

            """

   442

            def __init__(_self):

   443

                # self is the parent

   444

                _self.PlugParent = self

   445

                # Keep track of the plugin type name

   446

                _self.PlugType = PlugType

   447

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

   448

                PlugTemplate.__init__(_self)

   449

                # check name is unique

   450

                NewPlugName = _self.FindNewName(PlugName, logger)

   451

                # If dir have already be made, and file exist

   452

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

   453

                    #Load the plugin.xml file into parameters members

   454

                    _self.LoadXMLParams(NewPlugName)

   455

                    # Basic check. Better to fail immediately.

   456

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

   457

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

   458

   459

                    # Now, self.PlugPath() should be OK

   460

   461

                    # Check that IEC_Channel is not already in use.

   462

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

   463

                    # Call the plugin real __init__

   464

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

   465

                        PlugClass.__init__(_self)

   466

                    #Load and init all the childs

   467

                    _self.LoadChilds(logger)

   468

                else:

   469

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

   470

                    os.mkdir(_self.PlugPath())

   471

                    # Find an IEC number

   472

                    _self.FindNewIEC_Channel(0, None)

   473

                    # Call the plugin real __init__

   474

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

   475

                        PlugClass.__init__(_self)

   476

                    _self.PlugRequestSave()

   477

   478

            def _getBuildPath(_self):

   479

                return self._getBuildPath()

   480

   481

        # Create the object out of the resulting class

   482

        newPluginOpj = FinalPlugClass()

   483

        # Store it in PluggedChils

   484

        PluggedChildsWithSameClass.append(newPluginOpj)

   485

   486

        return newPluginOpj

   487