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):

   122

   123

    def PlugPath(self,PlugName=None):

   124

        if not PlugName:

   125

            PlugName = self.BaseParams.getName()

   126

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

   127

                            PlugName + NameTypeSeparator + self.PlugType)

   128

   129

    def PlugTestModified(self):

   130

        return self.ChangesToSave

   131

   132

    def ProjectTestModified(self):

   133

        """

   134

        recursively check modified status

   135

        """

   136

        if self.PlugTestModified():

   137

            return True

   138

   139

        for PlugChild in self.IterChilds():

   140

            if PlugChild.ProjectTestModified():

   141

                return True

   142

   143

        return False

   144

   145

    def OnPlugSave(self):

   146

        #Default, do nothing and return success

   147

        return True

   148

   149

    def GetParamsAttributes(self, path = None):

   150

        if path:

   151

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

   152

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

   153

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

   154

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

   155

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

   156

        else:

   157

            params = []

   158

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

   159

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

   160

            if self.PlugParams:

   161

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

   162

            return params

   163

   164

    def SetParamsAttribute(self, path, value):

   165

        self.ChangesToSave = True

   166

        # Filter IEC_Channel and Name, that have specific behavior

   167

        if path == "BaseParams.IEC_Channel":

   168

            return self.FindNewIEC_Channel(value), True

   169

        elif path == "BaseParams.Name":

   170

            res = self.FindNewName(value)

   171

            self.PlugRequestSave()

   172

            return res, True

   173

   174

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

   175

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

   176

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

   177

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

   178

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

   179

        return value, False

   180

   181

    def PlugRequestSave(self):

   182

        # If plugin do not have corresponding directory

   183

        plugpath = self.PlugPath()

   184

        if not os.path.isdir(plugpath):

   185

            # Create it

   186

            os.mkdir(plugpath)

   187

   188

        # generate XML for base XML parameters controller of the plugin

   189

        if self.MandatoryParams:

   190

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

   191

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

   192

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

   193

            BaseXMLFile.close()

   194

   195

        # generate XML for XML parameters controller of the plugin

   196

        if self.PlugParams:

   197

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

   198

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

   199

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

   200

            XMLFile.close()

   201

   202

        # Call the plugin specific OnPlugSave method

   203

        result = self.OnPlugSave()

   204

        if not result:

   205

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

   206

   207

        # mark plugin as saved

   208

        self.ChangesToSave = False        

   209

        # go through all childs and do the same

   210

        for PlugChild in self.IterChilds():

   211

            result = PlugChild.PlugRequestSave()

   212

            if result:

   213

                return result

   214

        return None

   215

   216

    def PlugImport(self, src_PlugPath):

   217

        shutil.copytree(src_PlugPath, self.PlugPath)

   218

        return True

   219

   220

    def PlugGenerate_C(self, buildpath, locations):

   221

        """

   222

        Generate C code

   223

        @param locations: List of complete variables locations \

   224

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

   225

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

   226

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

   227

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

   228

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

   229

            }, ...]

   230

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

   231

        """

   232

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

   233

        return [],"",False

   234

   235

    def _Generate_C(self, buildpath, locations):

   236

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

   237

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

   238

        gen_result = self.PlugGenerate_C(buildpath, locations)

   239

        PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = gen_result[:3]

   240

        extra_files = gen_result[3:]

   241

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

   242

        if PlugCFilesAndCFLAGS:

   243

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

   244

        else:

   245

            LocationCFilesAndCFLAGS = []

   246

   247

        # plugin asks for some LDFLAGS

   248

        if PlugLDFLAGS:

   249

            # LDFLAGS can be either string

   250

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

   251

                LDFLAGS=[PlugLDFLAGS]

   252

            #or list of strings

   253

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

   254

                LDFLAGS=PlugLDFLAGS[:]

   255

        else:

   256

            LDFLAGS=[]

   257

   258

        # recurse through all childs, and stack their results

   259

        for PlugChild in self.IECSortedChilds():

   260

            new_location = PlugChild.GetCurrentLocation()

   261

            # How deep are we in the tree ?

   262

            depth=len(new_location)

   263

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   264

                PlugChild._Generate_C(

   265

                    #keep the same path

   266

                    buildpath,

   267

                    # filter locations that start with current IEC location

   268

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

   269

            # stack the result

   270

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   271

            LDFLAGS += _LDFLAGS

   272

            extra_files += _extra_files

   273

   274

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   275

   276

    def BlockTypesFactory(self):

   277

        if self.LibraryControler is not None:

   278

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

   279

        return []

   280

   290

    def STLibraryFactory(self):

   291

        if self.LibraryControler is not None:

   292

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

   294

        return ""

   295

   302

    def IterChilds(self):

   303

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

   304

            for PlugInstance in PluggedChilds:

   305

                yield PlugInstance

   306

   307

    def IECSortedChilds(self):

   308

        # reorder childs by IEC_channels

   309

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

   310

        if ordered:

   311

            ordered.sort()

   312

            return zip(*ordered)[1]

   313

        else:

   314

            return []

   315

   316

    def _GetChildBySomething(self, something, toks):

   317

        for PlugInstance in self.IterChilds():

   318

            # if match component of the name

   319

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

   320

                # if Name have other components

   321

                if len(toks) >= 2:

   322

                    # Recurse in order to find the latest object

   323

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

   324

                # No sub name -> found

   325

                return PlugInstance

   326

        # Not found

   327

        return None

   328

   329

    def GetChildByName(self, Name):

   330

        if Name:

   331

            toks = Name.split('.')

   332

            return self._GetChildBySomething("Name", toks)

   333

        else:

   334

            return self

   335

   336

    def GetChildByIECLocation(self, Location):

   337

        if Location:

   338

            return self._GetChildBySomething("IEC_Channel", Location)

   339

        else:

   340

            return self

   341

   342

    def GetCurrentLocation(self):

   343

        """

   344

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

   345

        """

   346

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

   347

   348

    def GetCurrentName(self):

   349

        """

   350

        @return:  String "ParentParentName.ParentName.Name"

   351

        """

   352

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

   353

   354

    def _GetCurrentName(self):

   355

        """

   356

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

   357

        """

   358

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

   359

   360

    def GetPlugRoot(self):

   361

        return self.PlugParent.GetPlugRoot()

   362

   363

    def GetFullIEC_Channel(self):

   364

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

   365

   366

    def GetLocations(self):

   367

        location = self.GetCurrentLocation()

   368

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

   369

   370

    def GetPlugInfos(self):

   371

        childs = []

   372

        # reorder childs by IEC_channels

   373

        for child in self.IECSortedChilds():

   374

            childs.append(child.GetPlugInfos())

   375

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

   376

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

   377

        else:

   378

            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}

   379

   380

    def FindNewName(self, DesiredName):

   381

        """

   382

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

   383

        @param DesiredName: The desired Name (string)

   384

        """

   385

        # Get Current Name

   386

        CurrentName = self.BaseParams.getName()

   387

        # Do nothing if no change

   388

        #if CurrentName == DesiredName: return CurrentName

   389

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

   390

        AllNames=[]

   391

        for PlugInstance in self.PlugParent.IterChilds():

   392

            if PlugInstance != self:

   393

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

   394

   395

        # Find a free name, eventually appending digit

   396

        res = DesiredName

   397

        suffix = 1

   398

        while res in AllNames:

   399

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

   400

            suffix += 1

   401

   402

        # Get old path

   403

        oldname = self.PlugPath()

   404

        # Check previous plugin existance

   405

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

   406

        # Set the new name

   407

        self.BaseParams.setName(res)

   408

        # Rename plugin dir if exist

   409

        if not dontexist:

   410

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

   411

        # warn user he has two left hands

   412

        if DesiredName != res:

   413

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

   414

        return res

   415

   416

    def FindNewIEC_Channel(self, DesiredChannel):

   417

        """

   418

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

   419

        @param DesiredChannel: The desired IEC channel (int)

   420

        """

   421

        # Get Current IEC channel

   422

        CurrentChannel = self.BaseParams.getIEC_Channel()

   423

        # Do nothing if no change

   424

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   425

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

   426

        AllChannels=[]

   427

        for PlugInstance in self.PlugParent.IterChilds():

   428

            if PlugInstance != self:

   429

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

   430

        AllChannels.sort()

   431

   432

        # Now, try to guess the nearest available channel

   433

        res = DesiredChannel

   434

        while res in AllChannels: # While channel not free

   435

            if res < CurrentChannel: # Want to go down ?

   436

                res -=  1 # Test for n-1

   437

                if res < 0 :

   438

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

   439

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

   440

            else : # Want to go up ?

   441

                res +=  1 # Test for n-1

   442

        # Finally set IEC Channel

   443

        self.BaseParams.setIEC_Channel(res)

   444

        if DesiredChannel != res:

   445

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

   446

        return res

   447

   448

    def OnPlugClose(self):

   449

        return True

   450

   451

    def _doRemoveChild(self, PlugInstance):

   452

        # Remove all childs of child

   453

        for SubPlugInstance in PlugInstance.IterChilds():

   454

            PlugInstance._doRemoveChild(SubPlugInstance)

   455

        # Call the OnCloseMethod

   456

        PlugInstance.OnPlugClose()

   457

        # Delete plugin dir

   458

        shutil.rmtree(PlugInstance.PlugPath())

   459

        # Remove child of PluggedChilds

   460

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

   461

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

   462

   463

    def PlugRemove(self):

   464

        # Fetch the plugin

   465

        #PlugInstance = self.GetChildByName(PlugName)

   466

        # Ask to his parent to remove it

   467

        self.PlugParent._doRemoveChild(self)

   468

   469

    def PlugAddChild(self, PlugName, PlugType):

   470

        """

   471

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

   472

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

   473

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

   474

        """

   475

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

   476

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

   477

        transpose = zip(*self.PlugChildsTypes)

   478

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

   479

        # Check that adding this plugin is allowed

   480

        try:

   481

            PlugClass, PlugHelp = PlugChildsTypes[PlugType]

   482

        except KeyError:

   483

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

   484

   485

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