1

"""

     2

Base definitions for beremiz plugins

     3

"""

     4

     5

import os,sys,traceback

     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

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

    16

    17

from docpdf import *

    18

from xmlclass import GenerateClassesFromXSDstring

    19

from wxPopen import ProcessLogger

    20

    21

from PLCControler import PLCControler

    22

    23

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

    24

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

    25

          <xsd:element name="BaseParams">

    26

            <xsd:complexType>

    27

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

    28

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

    29

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

    30

            </xsd:complexType>

    31

          </xsd:element>

    32

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

    33

    34

NameTypeSeparator = '@'

    35

    36

class MiniTextControler:

    37

    38

    def __init__(self, filepath):

    39

        self.FilePath = filepath

    40

    41

    def SetEditedElementText(self, tagname, text):

    42

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

    43

        file.write(text)

    44

        file.close()

    45

    46

    def GetEditedElementText(self, tagname, debug = False):

    47

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

    48

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

    49

            text = file.read()

    50

            file.close()

    51

            return text

    52

        return ""

    53

    54

    def GetEditedElementInterfaceVars(self, tagname, debug = False):

    55

        return []

    56

    57

    def GetEditedElementType(self, tagname, debug = False):

    58

        return "program"

    59

    60

    def GetBlockTypes(self, tagname = "", debug = False):

    61

        return []

    62

    63

    def GetEnumeratedDataValues(self, debug = False):

    64

        return []

    65

    66

    def StartBuffering(self):

    67

        pass

    68

    69

    def EndBuffering(self):

    70

        pass

    71

    72

    def BufferProject(self):

    73

        pass

    74

    75

# helper func to get path to images

    76

def opjimg(imgname):

    77

    return os.path.join("images",imgname)

    78

    79

class PlugTemplate:

    80

    """

    81

    This class is the one that define plugins.

    82

    """

    83

    84

    XSD = None

    85

    PlugChildsTypes = []

    86

    PlugMaxCount = None

    87

    PluginMethods = []

    88

    LibraryControler = None

    89

    90

    def _AddParamsMembers(self):

    91

        self.PlugParams = None

    92

        if self.XSD:

    93

            Classes = GenerateClassesFromXSDstring(self.XSD)

    94

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

    95

            if len(Classes) == 1:

    96

                name, XSDclass = Classes[0]

    97

                obj = XSDclass()

    98

                self.PlugParams = (name, obj)

    99

                setattr(self, name, obj)

   100

   101

    def __init__(self):

   102

        # Create BaseParam 

   103

        self.BaseParams = _BaseParamsClass()

   104

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

   105

        self._AddParamsMembers()

   106

        self.PluggedChilds = {}

   107

        # copy PluginMethods so that it can be later customized

   108

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

   109

   110

    def PluginBaseXmlFilePath(self, PlugName=None):

   111

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

   112

   113

    def PluginXmlFilePath(self, PlugName=None):

   114

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

   115

   116

    def PluginLibraryFilePath(self, PlugName=None):

   117

        return os.path.join(os.path.join(os.path.split(__file__)[0], "plugins", self.PlugType, "pous.xml"))

   118

   119

    def PlugPath(self,PlugName=None):

   120

        if not PlugName:

   121

            PlugName = self.BaseParams.getName()

   122

        return os.path.join(self.PlugParent.PlugPath(),

   123

                            PlugName + NameTypeSeparator + self.PlugType)

   124

   125

    def PlugTestModified(self):

   126

        return self.ChangesToSave

   127

   128

    def ProjectTestModified(self):

   129

        """

   130

        recursively check modified status

   131

        """

   132

        if self.PlugTestModified():

   133

            return True

   134

   135

        for PlugChild in self.IterChilds():

   136

            if PlugChild.ProjectTestModified():

   137

                return True

   138

   139

        return False

   140

   141

    def OnPlugSave(self):

   142

        #Default, do nothing and return success

   143

        return True

   144

   145

    def GetParamsAttributes(self, path = None):

   146

        if path:

   147

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

   148

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

   149

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

   150

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

   151

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

   152

        else:

   153

            params = []

   154

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

   155

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

   156

            if self.PlugParams:

   157

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

   158

            return params

   159

   160

    def SetParamsAttribute(self, path, value):

   161

        self.ChangesToSave = True

   162

        # Filter IEC_Channel and Name, that have specific behavior

   163

        if path == "BaseParams.IEC_Channel":

   164

            return self.FindNewIEC_Channel(value), True

   165

        elif path == "BaseParams.Name":

   166

            res = self.FindNewName(value)

   167

            self.PlugRequestSave()

   168

            return res, True

   169

   170

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

   171

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

   172

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

   173

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

   174

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

   175

        return value, False

   176

   177

    def PlugRequestSave(self):

   178

        # If plugin do not have corresponding directory

   179

        plugpath = self.PlugPath()

   180

        if not os.path.isdir(plugpath):

   181

            # Create it

   182

            os.mkdir(plugpath)

   183

   184

        # generate XML for base XML parameters controller of the plugin

   185

        if self.MandatoryParams:

   186

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

   187

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

   188

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

   189

            BaseXMLFile.close()

   190

   191

        # generate XML for XML parameters controller of the plugin

   192

        if self.PlugParams:

   193

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

   194

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

   195

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

   196

            XMLFile.close()

   197

   198

        # Call the plugin specific OnPlugSave method

   199

        result = self.OnPlugSave()

   200

        if not result:

   201

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

   202

   203

        # mark plugin as saved

   204

        self.ChangesToSave = False        

   205

        # go through all childs and do the same

   206

        for PlugChild in self.IterChilds():

   207

            result = PlugChild.PlugRequestSave()

   208

            if result:

   209

                return result

   210

        return None

   211

   212

    def PlugImport(self, src_PlugPath):

   213

        shutil.copytree(src_PlugPath, self.PlugPath)

   214

        return True

   215

   216

    def PlugGenerate_C(self, buildpath, locations):

   217

        """

   218

        Generate C code

   219

        @param locations: List of complete variables locations \

   220

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

   221

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

   222

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

   223

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

   224

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

   225

            }, ...]

   226

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

   227

        """

   228

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

   229

        return [],"",False

   230

   231

    def _Generate_C(self, buildpath, locations):

   232

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

   233

        # extra_files = [(fname,fobject), ...]

   234

        gen_result = self.PlugGenerate_C(buildpath, locations)

   235

        PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = gen_result[:3]

   236

        extra_files = gen_result[3:]

   237

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

   238

        if PlugCFilesAndCFLAGS:

   239

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

   240

        else:

   241

            LocationCFilesAndCFLAGS = []

   242

   243

        # plugin asks for some LDFLAGS

   244

        if PlugLDFLAGS:

   245

            # LDFLAGS can be either string

   246

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

   247

                LDFLAGS=[PlugLDFLAGS]

   248

            #or list of strings

   249

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

   250

                LDFLAGS=PlugLDFLAGS[:]

   251

        else:

   252

            LDFLAGS=[]

   253

   254

        # recurse through all childs, and stack their results

   255

        for PlugChild in self.IECSortedChilds():

   256

            new_location = PlugChild.GetCurrentLocation()

   257

            # How deep are we in the tree ?

   258

            depth=len(new_location)

   259

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   260

                PlugChild._Generate_C(

   261

                    #keep the same path

   262

                    buildpath,

   263

                    # filter locations that start with current IEC location

   264

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

   265

            # stack the result

   266

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   267

            LDFLAGS += _LDFLAGS

   268

            extra_files += _extra_files

   269

   270

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   271

   272

    def BlockTypesFactory(self):

   273

        if self.LibraryControler is not None:

   274

            return [{"name" : "%s POUs" % self.PlugType, "list": self.LibraryControler.Project.GetCustomBlockTypes()}]

   275

        return []

   276

   277

    def STLibraryFactory(self):

   278

        if self.LibraryControler is not None:

   279

            return self.LibraryControler.GenerateProgram()

   280

        return ""

   281

   282

    def IterChilds(self):

   283

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

   284

            for PlugInstance in PluggedChilds:

   285

                yield PlugInstance

   286

   287

    def IECSortedChilds(self):

   288

        # reorder childs by IEC_channels

   289

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

   290

        if ordered:

   291

            ordered.sort()

   292

            return zip(*ordered)[1]

   293

        else:

   294

            return []

   295

   296

    def _GetChildBySomething(self, something, toks):

   297

        for PlugInstance in self.IterChilds():

   298

            # if match component of the name

   299

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

   300

                # if Name have other components

   301

                if len(toks) >= 2:

   302

                    # Recurse in order to find the latest object

   303

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

   304

                # No sub name -> found

   305

                return PlugInstance

   306

        # Not found

   307

        return None

   308

   309

    def GetChildByName(self, Name):

   310

        if Name:

   311

            toks = Name.split('.')

   312

            return self._GetChildBySomething("Name", toks)

   313

        else:

   314

            return self

   315

   316

    def GetChildByIECLocation(self, Location):

   317

        if Location:

   318

            return self._GetChildBySomething("IEC_Channel", Location)

   319

        else:

   320

            return self

   321

   322

    def GetCurrentLocation(self):

   323

        """

   324

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

   325

        """

   326

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

   327

   328

    def GetCurrentName(self):

   329

        """

   330

        @return:  String "ParentParentName.ParentName.Name"

   331

        """

   332

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

   333

   334

    def _GetCurrentName(self):

   335

        """

   336

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

   337

        """

   338

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

   339

   340

    def GetPlugRoot(self):

   341

        return self.PlugParent.GetPlugRoot()

   342

   343

    def GetFullIEC_Channel(self):

   344

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

   345

   346

    def GetLocations(self):

   347

        location = self.GetCurrentLocation()

   348

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

   349

   350

    def GetPlugInfos(self):

   351

        childs = []

   352

        # reorder childs by IEC_channels

   353

        for child in self.IECSortedChilds():

   354

            childs.append(child.GetPlugInfos())

   355

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

   356

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

   357

        else:

   358

            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}

   359

   360

    def FindNewName(self, DesiredName):

   361

        """

   362

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

   363

        @param DesiredName: The desired Name (string)

   364

        """

   365

        # Get Current Name

   366

        CurrentName = self.BaseParams.getName()

   367

        # Do nothing if no change

   368

        #if CurrentName == DesiredName: return CurrentName

   369

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

   370

        AllNames=[]

   371

        for PlugInstance in self.PlugParent.IterChilds():

   372

            if PlugInstance != self:

   373

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

   374

   375

        # Find a free name, eventually appending digit

   376

        res = DesiredName

   377

        suffix = 1

   378

        while res in AllNames:

   379

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

   380

            suffix += 1

   381

   382

        # Get old path

   383

        oldname = self.PlugPath()

   384

        # Check previous plugin existance

   385

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

   386

        # Set the new name

   387

        self.BaseParams.setName(res)

   388

        # Rename plugin dir if exist

   389

        if not dontexist:

   390

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

   391

        # warn user he has two left hands

   392

        if DesiredName != res:

   393

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

   394

        return res

   395

   396

    def FindNewIEC_Channel(self, DesiredChannel):

   397

        """

   398

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

   399

        @param DesiredChannel: The desired IEC channel (int)

   400

        """

   401

        # Get Current IEC channel

   402

        CurrentChannel = self.BaseParams.getIEC_Channel()

   403

        # Do nothing if no change

   404

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   405

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

   406

        AllChannels=[]

   407

        for PlugInstance in self.PlugParent.IterChilds():

   408

            if PlugInstance != self:

   409

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

   410

        AllChannels.sort()

   411

   412

        # Now, try to guess the nearest available channel

   413

        res = DesiredChannel

   414

        while res in AllChannels: # While channel not free

   415

            if res < CurrentChannel: # Want to go down ?

   416

                res -=  1 # Test for n-1

   417

                if res < 0 :

   418

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

   419

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

   420

            else : # Want to go up ?

   421

                res +=  1 # Test for n-1

   422

        # Finally set IEC Channel

   423

        self.BaseParams.setIEC_Channel(res)

   424

        if DesiredChannel != res:

   425

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

   426

        return res

   427

   428

    def OnPlugClose(self):

   429

        return True

   430

   431

    def _doRemoveChild(self, PlugInstance):

   432

        # Remove all childs of child

   433

        for SubPlugInstance in PlugInstance.IterChilds():

   434

            PlugInstance._doRemoveChild(SubPlugInstance)

   435

        # Call the OnCloseMethod

   436

        PlugInstance.OnPlugClose()

   437

        # Delete plugin dir

   438

        shutil.rmtree(PlugInstance.PlugPath())

   439

        # Remove child of PluggedChilds

   440

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

   441

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

   442

   443

    def PlugRemove(self):

   444

        # Fetch the plugin

   445

        #PlugInstance = self.GetChildByName(PlugName)

   446

        # Ask to his parent to remove it

   447

        self.PlugParent._doRemoveChild(self)

   448

   449

    def PlugAddChild(self, PlugName, PlugType):

   450

        """

   451

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

   452

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

   453

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

   454

        """

   455

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

   456

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

   457

        transpose = zip(*self.PlugChildsTypes)

   458

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

   459

        # Check that adding this plugin is allowed

   460

        try:

   461

            PlugClass, PlugHelp = PlugChildsTypes[PlugType]

   462

        except KeyError:

   463

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

   464

   465

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

   466

        if type(PlugClass) == types.FunctionType:

   467

            PlugClass = PlugClass()

   468

   469

        # Eventualy Initialize child instance list for this class of plugin

   470

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

   471

        # Check count

   472

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

   473

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

   474

   475

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

   476

        class FinalPlugClass(PlugClass, PlugTemplate):

   477

            """

   478

            Plugin class is derivated into FinalPlugClass before being instanciated

   479

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

   480

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

   481

            """

   482

            def __init__(_self):

   483

                # self is the parent

   484

                _self.PlugParent = self

   485

                # self is the parent

   486

                _self.logger = self.logger