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

        self.LoadSTLibrary()

   110

   111

    def PluginBaseXmlFilePath(self, PlugName=None):

   112

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

   113

   114

    def PluginXmlFilePath(self, PlugName=None):

   115

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

   116

   117

    def PluginLibraryFilePath(self):

   118

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

   119

   120

    def PlugPath(self,PlugName=None):

   121

        if not PlugName:

   122

            PlugName = self.BaseParams.getName()

   123

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

   124

                            PlugName + NameTypeSeparator + self.PlugType)

   125

   126

    def PlugTestModified(self):

   127

        return self.ChangesToSave

   128

   129

    def ProjectTestModified(self):

   130

        """

   131

        recursively check modified status

   132

        """

   133

        if self.PlugTestModified():

   134

            return True

   135

   136

        for PlugChild in self.IterChilds():

   137

            if PlugChild.ProjectTestModified():

   138

                return True

   139

   140

        return False

   141

   142

    def OnPlugSave(self):

   143

        #Default, do nothing and return success

   144

        return True

   145

   146

    def GetParamsAttributes(self, path = None):

   147

        if path:

   148

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

   149

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

   150

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

   151

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

   152

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

   153

        else:

   154

            params = []

   155

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

   156

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

   157

            if self.PlugParams:

   158

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

   159

            return params

   160

   161

    def SetParamsAttribute(self, path, value):

   162

        self.ChangesToSave = True

   163

        # Filter IEC_Channel and Name, that have specific behavior

   164

        if path == "BaseParams.IEC_Channel":

   165

            return self.FindNewIEC_Channel(value), True

   166

        elif path == "BaseParams.Name":

   167

            res = self.FindNewName(value)

   168

            self.PlugRequestSave()

   169

            return res, True

   170

   171

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

   172

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

   173

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

   174

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

   175

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

   176

        return value, False

   177

   178

    def PlugRequestSave(self):

   179

        # If plugin do not have corresponding directory

   180

        plugpath = self.PlugPath()

   181

        if not os.path.isdir(plugpath):

   182

            # Create it

   183

            os.mkdir(plugpath)

   184

   185

        # generate XML for base XML parameters controller of the plugin

   186

        if self.MandatoryParams:

   187

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

   188

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

   189

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

   190

            BaseXMLFile.close()

   191

   192

        # generate XML for XML parameters controller of the plugin

   193

        if self.PlugParams:

   194

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

   195

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

   196

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

   197

            XMLFile.close()

   198

   199

        # Call the plugin specific OnPlugSave method

   200

        result = self.OnPlugSave()

   201

        if not result:

   203

   204

        # mark plugin as saved

   205

        self.ChangesToSave = False        

   206

        # go through all childs and do the same

   207

        for PlugChild in self.IterChilds():

   208

            result = PlugChild.PlugRequestSave()

   209

            if result:

   210

                return result

   211

        return None

   212

   213

    def PlugImport(self, src_PlugPath):

   214

        shutil.copytree(src_PlugPath, self.PlugPath)

   215

        return True

   216

   217

    def PlugGenerate_C(self, buildpath, locations):

   218

        """

   219

        Generate C code

   220

        @param locations: List of complete variables locations \

   221

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

   222

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

   223

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

   224

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

   225

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

   226

            }, ...]

   227

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

   228

        """

   229

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

   230

        return [],"",False

   231

   232

    def _Generate_C(self, buildpath, locations):

   233

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

   234

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

   235

        gen_result = self.PlugGenerate_C(buildpath, locations)

   236

        PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = gen_result[:3]

   237

        extra_files = gen_result[3:]

   239

        if PlugCFilesAndCFLAGS:

   240

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

   241

        else:

   242

            LocationCFilesAndCFLAGS = []

   243

   244

        # plugin asks for some LDFLAGS

   245

        if PlugLDFLAGS:

   246

            # LDFLAGS can be either string

   247

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

   248

                LDFLAGS=[PlugLDFLAGS]

   249

            #or list of strings

   250

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

   251

                LDFLAGS=PlugLDFLAGS[:]

   252

        else:

   253

            LDFLAGS=[]

   254

   255

        # recurse through all childs, and stack their results

   256

        for PlugChild in self.IECSortedChilds():

   257

            new_location = PlugChild.GetCurrentLocation()

   258

            # How deep are we in the tree ?

   259

            depth=len(new_location)

   260

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   261

                PlugChild._Generate_C(

   262

                    #keep the same path

   263

                    buildpath,

   264

                    # filter locations that start with current IEC location

   265

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

   266

            # stack the result

   267

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   268

            LDFLAGS += _LDFLAGS

   269

            extra_files += _extra_files

   270

   271

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   272

   273

    def BlockTypesFactory(self):

   274

        if self.LibraryControler is not None:

   275

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

   276

        return []

   277

   278

    def STLibraryFactory(self):

   279

        if self.LibraryControler is not None:

   280

            program, errors, warnings = self.LibraryControler.GenerateProgram()

   281

            return program

   282

        return ""

   283

   284

    def IterChilds(self):

   285

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

   286

            for PlugInstance in PluggedChilds:

   287

                yield PlugInstance

   288

   289

    def IECSortedChilds(self):

   290

        # reorder childs by IEC_channels

   291

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

   292

        if ordered:

   293

            ordered.sort()

   294

            return zip(*ordered)[1]

   295

        else:

   296

            return []

   297

   298

    def _GetChildBySomething(self, something, toks):

   299

        for PlugInstance in self.IterChilds():

   300

            # if match component of the name

   301

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

   302

                # if Name have other components

   303

                if len(toks) >= 2:

   304

                    # Recurse in order to find the latest object

   305

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

   306

                # No sub name -> found

   307

                return PlugInstance

   308

        # Not found

   309

        return None

   310

   311

    def GetChildByName(self, Name):

   312

        if Name:

   313

            toks = Name.split('.')

   314

            return self._GetChildBySomething("Name", toks)

   315

        else:

   316

            return self

   317

   318

    def GetChildByIECLocation(self, Location):

   319

        if Location:

   320

            return self._GetChildBySomething("IEC_Channel", Location)

   321

        else:

   322

            return self

   323

   324

    def GetCurrentLocation(self):

   325

        """

   326

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

   327

        """

   328

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

   329

   330

    def GetCurrentName(self):

   331

        """

   332

        @return:  String "ParentParentName.ParentName.Name"

   333

        """

   334

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

   335

   336

    def _GetCurrentName(self):

   337

        """

   338

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

   339

        """

   340

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

   341

   342

    def GetPlugRoot(self):

   343

        return self.PlugParent.GetPlugRoot()

   344

   345

    def GetFullIEC_Channel(self):

   346

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

   347

   348

    def GetLocations(self):

   349

        location = self.GetCurrentLocation()

   350

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

   351

   352

    def GetPlugInfos(self):

   353

        childs = []

   354

        # reorder childs by IEC_channels

   355

        for child in self.IECSortedChilds():

   356

            childs.append(child.GetPlugInfos())

   357

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

   358

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

   359

        else:

   360

            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}

   361

   362

    def FindNewName(self, DesiredName):

   363

        """

   364

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

   365

        @param DesiredName: The desired Name (string)

   366

        """

   367

        # Get Current Name

   368

        CurrentName = self.BaseParams.getName()

   369

        # Do nothing if no change

   370

        #if CurrentName == DesiredName: return CurrentName

   371

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

   372

        AllNames=[]

   373

        for PlugInstance in self.PlugParent.IterChilds():

   374

            if PlugInstance != self:

   375

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

   376

   377

        # Find a free name, eventually appending digit

   378

        res = DesiredName

   379

        suffix = 1

   380

        while res in AllNames:

   381

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

   382

            suffix += 1

   383

   384

        # Get old path

   385

        oldname = self.PlugPath()

   386

        # Check previous plugin existance

   387

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

   388

        # Set the new name

   389

        self.BaseParams.setName(res)

   390

        # Rename plugin dir if exist

   391

        if not dontexist:

   392

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

   393

        # warn user he has two left hands

   394

        if DesiredName != res:

   396

        return res

   397

   398

    def FindNewIEC_Channel(self, DesiredChannel):

   399

        """

   400

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

   401

        @param DesiredChannel: The desired IEC channel (int)

   402

        """

   403

        # Get Current IEC channel

   404

        CurrentChannel = self.BaseParams.getIEC_Channel()

   405

        # Do nothing if no change

   406

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   407

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

   408

        AllChannels=[]

   409

        for PlugInstance in self.PlugParent.IterChilds():

   410

            if PlugInstance != self:

   411

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

   412

        AllChannels.sort()

   413

   414

        # Now, try to guess the nearest available channel

   415

        res = DesiredChannel

   416

        while res in AllChannels: # While channel not free

   417

            if res < CurrentChannel: # Want to go down ?

   418

                res -=  1 # Test for n-1

   419

                if res < 0 :

   421

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

   422

            else : # Want to go up ?

   423

                res +=  1 # Test for n-1

   424

        # Finally set IEC Channel

   425

        self.BaseParams.setIEC_Channel(res)

   426

        if DesiredChannel != res:

   428

        return res

   429

   430

    def OnPlugClose(self):

   431

        return True

   432

   433

    def _doRemoveChild(self, PlugInstance):

   434

        # Remove all childs of child

   435

        for SubPlugInstance in PlugInstance.IterChilds():

   436

            PlugInstance._doRemoveChild(SubPlugInstance)

   437

        # Call the OnCloseMethod

   438

        PlugInstance.OnPlugClose()

   439

        # Delete plugin dir

   440

        shutil.rmtree(PlugInstance.PlugPath())

   441

        # Remove child of PluggedChilds

   442

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

   443

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

   444

   445

    def PlugRemove(self):

   446

        # Fetch the plugin

   447

        #PlugInstance = self.GetChildByName(PlugName)

   448

        # Ask to his parent to remove it

   449

        self.PlugParent._doRemoveChild(self)

   450

   451

    def PlugAddChild(self, PlugName, PlugType):

   452

        """

   453

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

   454

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

   455

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

   456

        """

   457

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

   458

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

   459

        transpose = zip(*self.PlugChildsTypes)

   460

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

   461

        # Check that adding this plugin is allowed

   462

        try:

   463

            PlugClass, PlugHelp = PlugChildsTypes[PlugType]

   464

        except KeyError:

   466

   467

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

   468

        if type(PlugClass) == types.FunctionType:

   469

            PlugClass = PlugClass()

   470

   471

        # Eventualy Initialize child instance list for this class of plugin

   472

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

   473

        # Check count

   474

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

   476

   477

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

   478

        class FinalPlugClass(PlugClass, PlugTemplate):

   479

            """

   480

            Plugin class is derivated into FinalPlugClass before being instanciated

   481

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

   482

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

   483

            """

   484

            def __init__(_self):

   485

                # self is the parent