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

    12

    13

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

    14

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

    15

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

    16

    17

from xmlclass import GenerateClassesFromXSDstring

    18

    19

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

    20

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

    21

          <xsd:element name="BaseParams">

    22

            <xsd:complexType>

    23

              <xsd:attribute name="Name" type="xsd:string" use="optional" default="__unnamed__"/>

    24

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

    25

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

    26

            </xsd:complexType>

    27

          </xsd:element>

    28

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

    29

    30

NameTypeSeparator = '@'

    31

    32

class MiniTextControler:

    33

    34

    def __init__(self, filepath):

    35

        self.FilePath = filepath

    36

    37

    def SetEditedElementText(self, tagname, text):

    38

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

    39

        file.write(text)

    40

        file.close()

    41

    42

    def GetEditedElementText(self, tagname):

    43

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

    44

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

    45

            text = file.read()

    46

            file.close()

    47

            return text

    48

        return ""

    49

    50

    def GetEditedElementInterfaceVars(self, tagname):

    51

        return []

    52

    53

    def GetEditedElementType(self, tagname):

    54

        return "program"

    55

    56

    def GetBlockTypes(self, tagname = ""):

    57

        return []

    58

    59

    def GetEnumeratedDataValues(self):

    60

        return []

    61

    62

    def StartBuffering(self):

    63

        pass

    64

    65

    def EndBuffering(self):

    66

        pass

    67

    68

    def BufferProject(self):

    69

        pass

    70

    71

class PlugTemplate:

    72

    """

    73

    This class is the one that define plugins.

    74

    """

    75

    76

    XSD = None

    77

    PlugChildsTypes = []

    78

    PlugMaxCount = None

    79

    PluginMethods = []

    80

    81

    def _AddParamsMembers(self):

    82

        self.PlugParams = None

    83

        if self.XSD:

    84

            Classes = GenerateClassesFromXSDstring(self.XSD)

    85

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

    86

            if len(Classes) == 1:

    87

                name, XSDclass = Classes[0]

    88

                obj = XSDclass()

    89

                self.PlugParams = (name, obj)

    90

                setattr(self, name, obj)

    91

    92

    def __init__(self):

    93

        # Create BaseParam 

    94

        self.BaseParams = _BaseParamsClass()

    95

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

    96

        self._AddParamsMembers()

    97

        self.PluggedChilds = {}

    98

        # copy PluginMethods so that it can be later customized

    99

        self.PluginMethods = [dic.copy() for dic in self.PluginMethods]

   100

   101

    def PluginBaseXmlFilePath(self, PlugName=None):

   102

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

   103

   104

    def PluginXmlFilePath(self, PlugName=None):

   105

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

   106

   107

    def PlugPath(self,PlugName=None):

   108

        if not PlugName:

   109

            PlugName = self.BaseParams.getName()

   110

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

   111

   112

    def PlugTestModified(self):

   113

        return False

   114

   115

    def OnPlugSave(self):

   116

        #Default, do nothing and return success

   117

        return True

   118

   119

    def GetParamsAttributes(self, path = None):

   120

        if path:

   121

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

   122

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

   123

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

   124

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

   125

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

   126

        else:

   127

            params = []

   128

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

   129

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

   130

            if self.PlugParams:

   131

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

   132

            return params

   133

   134

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

   135

        # Filter IEC_Channel and Name, that have specific behavior

   136

        if path == "BaseParams.IEC_Channel":

   137

            return self.FindNewIEC_Channel(value,logger), True

   138

        elif path == "BaseParams.Name":

   139

            res = self.FindNewName(value,logger)

   140

            self.PlugRequestSave()

   141

            return res, False

   142

   143

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

   144

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

   145

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

   146

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

   147

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

   148

        return value, False

   149

   150

    def PlugRequestSave(self):

   151

        # If plugin do not have corresponding directory

   152

        plugpath = self.PlugPath()

   153

        if not os.path.isdir(plugpath):

   154

            # Create it

   155

            os.mkdir(plugpath)

   156

   157

        # generate XML for base XML parameters controller of the plugin

   158

        if self.MandatoryParams:

   159

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

   160

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

   161

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

   162

            BaseXMLFile.close()

   163

   164

        # generate XML for XML parameters controller of the plugin

   165

        if self.PlugParams:

   166

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

   167

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

   168

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

   169

            XMLFile.close()

   170

   171

        # Call the plugin specific OnPlugSave method

   172

        result = self.OnPlugSave()

   173

        if not result:

   174

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

   175

   176

        # go through all childs and do the same

   177

        for PlugChild in self.IterChilds():

   178

            result = PlugChild.PlugRequestSave()

   179

            if result:

   180

                return result

   181

        return None

   182

   183

    def PlugImport(self, src_PlugPath):

   184

        shutil.copytree(src_PlugPath, self.PlugPath)

   185

        return True

   186

   187

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

   188

        """

   189

        Generate C code

   190

        @param locations: List of complete variables locations \

   191

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

   192

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

   193

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

   194

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

   195

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

   196

            }, ...]

   197

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

   198

        """

   199

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

   200

        return [],"",False

   201

   202

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

   203

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

   204

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

   205

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

   206

        if PlugCFilesAndCFLAGS:

   207

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

   208

        else:

   209

            LocationCFilesAndCFLAGS = []

   210

   211

        # plugin asks some some LDFLAGS

   212

        if PlugLDFLAGS:

   213

            # LDFLAGS can be either string

   214

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

   215

                LDFLAGS=[PlugLDFLAGS]

   216

            #or list of strings

   217

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

   218

                LDFLAGS=PlugLDFLAGS[:]

   219

        else:

   220

            LDFLAGS=[]

   221

   222

        # recurse through all childs, and stack their results

   223

        for PlugChild in self.IECSortedChilds():

   224

            new_location = PlugChild.GetCurrentLocation()

   225

            # How deep are we in the tree ?

   226

            depth=len(new_location)

   227

            _LocationCFilesAndCFLAGS, _LDFLAGS = \

   228

                PlugChild._Generate_C(

   229

                    #keep the same path

   230

                    buildpath,

   231

                    # filter locations that start with current IEC location

   232

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

   233

                    #propagete logger

   234

                    logger)

   235

            # stack the result

   236

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   237

            LDFLAGS += _LDFLAGS

   238

   239

        return LocationCFilesAndCFLAGS,LDFLAGS

   240

   241

    def BlockTypesFactory(self):

   242

        return []

   243

   244

    def STLibraryFactory(self):

   245

        return ""

   246

   247

    def IterChilds(self):

   248

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

   249

            for PlugInstance in PluggedChilds:

   250

                   yield PlugInstance

   251

   252

    def IECSortedChilds(self):

   253

        # reorder childs by IEC_channels

   254

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

   255

        if ordered:

   256

            ordered.sort()

   257

            return zip(*ordered)[1]

   258

        else:

   259

            return []

   260

   261

    def _GetChildBySomething(self, something, toks):

   262

        for PlugInstance in self.IterChilds():

   263

            # if match component of the name

   264

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

   265

                # if Name have other components

   266

                if len(toks) >= 2:

   267

                    # Recurse in order to find the latest object

   268

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

   269

                # No sub name -> found

   270

                return PlugInstance

   271

        # Not found

   272

        return None

   273

   274

    def GetChildByName(self, Name):

   275

        if Name:

   276

            toks = Name.split('.')

   277

            return self._GetChildBySomething("Name", toks)

   278

        else:

   279

            return self

   280

   281

    def GetChildByIECLocation(self, Location):

   282

        if Location:

   283

            return self._GetChildBySomething("IEC_Channel", Location)

   284

        else:

   285

            return self

   286

   287

    def GetCurrentLocation(self):

   288

        """

   289

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

   290

        """

   291

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

   292

   293

    def GetCurrentName(self):

   294

        """

   295

        @return:  String "ParentParentName.ParentName.Name"

   296

        """

   297

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

   298

   299

    def _GetCurrentName(self):

   300

        """

   301

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

   302

        """

   303

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

   304

   305

    def GetPlugRoot(self):

   306

        return self.PlugParent.GetPlugRoot()

   307

   308

    def GetFullIEC_Channel(self):

   309

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

   310

   311

    def GetLocations(self):

   312

        location = self.GetCurrentLocation()

   313

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

   314

   315

    def GetPlugInfos(self):

   316

        childs = []

   317

        # reorder childs by IEC_channels

   318

        for child in self.IECSortedChilds():

   319

            childs.append(child.GetPlugInfos())

   320

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

   321

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

   322

        else:

   323

            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}

   324

   325

    def FindNewName(self, DesiredName, logger):

   326

        """

   327

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

   328

        @param DesiredName: The desired Name (string)

   329

        """

   330

        # Get Current Name

   331

        CurrentName = self.BaseParams.getName()

   332

        # Do nothing if no change

   333

        #if CurrentName == DesiredName: return CurrentName

   334

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

   335

        AllNames=[]

   336

        for PlugInstance in self.PlugParent.IterChilds():

   337

            if PlugInstance != self:

   338

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

   339

   340

        # Find a free name, eventually appending digit

   341

        res = DesiredName

   342

        suffix = 1

   343

        while res in AllNames:

   344

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

   345

            suffix += 1

   346

   347

        # Get old path

   348

        oldname = self.PlugPath()

   349

        # Check previous plugin existance

   350

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

   351

        # Set the new name

   352

        self.BaseParams.setName(res)

   353

        # Rename plugin dir if exist

   354

        if not dontexist:

   355

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

   356

        # warn user he has two left hands

   357

        if DesiredName != res:

   358

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

   359

        return res

   360

   361

    def FindNewIEC_Channel(self, DesiredChannel, logger):

   362

        """

   363

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

   364

        @param DesiredChannel: The desired IEC channel (int)

   365

        """

   366

        # Get Current IEC channel

   367

        CurrentChannel = self.BaseParams.getIEC_Channel()

   368

        # Do nothing if no change

   369

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   370

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

   371

        AllChannels=[]

   372

        for PlugInstance in self.PlugParent.IterChilds():

   373

            if PlugInstance != self:

   374

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

   375

        AllChannels.sort()

   376

   377

        # Now, try to guess the nearest available channel

   378

        res = DesiredChannel

   379

        while res in AllChannels: # While channel not free

   380

            if res < CurrentChannel: # Want to go down ?

   381

                res -=  1 # Test for n-1

   382

                if res < 0 :

   383

                    if logger :

   384

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

   385

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

   386

            else : # Want to go up ?

   387

                res +=  1 # Test for n-1

   388

        # Finally set IEC Channel

   389

        self.BaseParams.setIEC_Channel(res)

   390

        if logger and DesiredChannel != res:

   391

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

   392

        return res

   393

   394

    def OnPlugClose(self):

   395

        return True

   396

   397

    def _doRemoveChild(self, PlugInstance):

   398

        # Remove all childs of child

   399

        for SubPlugInstance in PlugInstance.IterChilds():

   400

            PlugInstance._doRemoveChild(SubPlugInstance)

   401

        # Call the OnCloseMethod

   402

        PlugInstance.OnPlugClose()

   403

        # Delete plugin dir

   404

        shutil.rmtree(PlugInstance.PlugPath())

   405

        # Remove child of PluggedChilds

   406

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

   407

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

   408

   409

    def PlugRemove(self):

   410

        # Fetch the plugin

   411

        #PlugInstance = self.GetChildByName(PlugName)

   412

        # Ask to his parent to remove it

   413

        self.PlugParent._doRemoveChild(self)

   414

   415

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

   416

        """

   417

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

   418

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

   419

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

   420

        """

   421

        # reorgabize self.PlugChildsTypes tuples from (name, PlugClass, Help)

   422

        # to ( name, (PlugClass, Help)), an make a dict

   423

        transpose = zip(*self.PlugChildsTypes)

   424

        PlugChildsTypes = dict(zip(transpose[0],zip(transpose[1],transpose[2])))

   425

        # Check that adding this plugin is allowed

   426

        try:

   427

            PlugClass, PlugHelp = PlugChildsTypes[PlugType]

   428

        except KeyError:

   429

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

   430

   431

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

   432

        if type(PlugClass) == types.FunctionType:

   433

            PlugClass = PlugClass()

   434

   435

        # Eventualy Initialize child instance list for this class of plugin

   436

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

   437

        # Check count

   438

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

   439

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

   440

   441

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

   442

        class FinalPlugClass(PlugClass, PlugTemplate):

   443

            """

   444

            Plugin class is derivated into FinalPlugClass before being instanciated

   445

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

   446

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

   447

            """

   448

            def __init__(_self):

   449

                # self is the parent

   450

                _self.PlugParent = self

   451

                # Keep track of the plugin type name

   452

                _self.PlugType = PlugType

   453

                # remind the help string, for more fancy display

   454

                _self.PlugHelp = PlugHelp

   455

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

   456

                PlugTemplate.__init__(_self)

   457

                # check name is unique

   458

                NewPlugName = _self.FindNewName(PlugName, logger)

   459

                # If dir have already be made, and file exist

   460

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

   461

                    #Load the plugin.xml file into parameters members

   462

                    _self.LoadXMLParams(logger, NewPlugName)

   463

                    # Basic check. Better to fail immediately.

   464

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

   465

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

   466

   467

                    # Now, self.PlugPath() should be OK

   468

   469

                    # Check that IEC_Channel is not already in use.

   470

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

   471

                    # Call the plugin real __init__

   472

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

   473

                        PlugClass.__init__(_self)

   474

                    #Load and init all the childs

   475

                    _self.LoadChilds(logger)

   476

                else:

   477

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

   478

                    os.mkdir(_self.PlugPath())

   479

                    # Find an IEC number

   480

                    _self.FindNewIEC_Channel(0, None)

   481

                    # Call the plugin real __init__

   482

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

   483

                        PlugClass.__init__(_self)

   484

                    _self.PlugRequestSave()

   485

   486

            def _getBuildPath(_self):

   487

                return self._getBuildPath()