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

    15

from docpdf import *

    16

from xmlclass import GenerateClassesFromXSDstring

    17

from wxPopen import ProcessLogger

    18

    19

from PLCControler import PLCControler

    20

    21

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

    22

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

    23

          <xsd:element name="BaseParams">

    24

            <xsd:complexType>

    25

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

    26

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

    27

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

    28

            </xsd:complexType>

    29

          </xsd:element>

    30

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

    31

    32

NameTypeSeparator = '@'

    33

    34

class MiniTextControler:

    35

    36

    def __init__(self, filepath):

    37

        self.FilePath = filepath

    38

    39

    def SetEditedElementText(self, tagname, text):

    40

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

    41

        file.write(text)

    42

        file.close()

    43

    44

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

    45

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

    46

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

    47

            text = file.read()

    48

            file.close()

    49

            return text

    50

        return ""

    51

    52

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

    53

        return []

    54

    55

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

    56

        return "program"

    57

    58

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

    59

        return []

    60

    61

    def GetEnumeratedDataValues(self, debug = False):

    62

        return []

    63

    64

    def StartBuffering(self):

    65

        pass

    66

    67

    def EndBuffering(self):

    68

        pass

    69

    70

    def BufferProject(self):

    71

        pass

    72

    73

# helper func to get path to images

    74

def opjimg(imgname):

    75

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

    76

    77

class PlugTemplate:

    78

    """

    79

    This class is the one that define plugins.

    80

    """

    81

    82

    XSD = None

    83

    PlugChildsTypes = []

    84

    PlugMaxCount = None

    85

    PluginMethods = []

    86

    LibraryControler = None

    87

    88

    def _AddParamsMembers(self):

    89

        self.PlugParams = None

    90

        if self.XSD:

    91

            Classes = GenerateClassesFromXSDstring(self.XSD)

    92

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

    93

            if len(Classes) == 1:

    94

                name, XSDclass = Classes[0]

    95

                obj = XSDclass()

    96

                self.PlugParams = (name, obj)

    97

                setattr(self, name, obj)

    98

    99

    def __init__(self):

   100

        # Create BaseParam 

   101

        self.BaseParams = _BaseParamsClass()

   102

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

   103

        self._AddParamsMembers()

   104

        self.PluggedChilds = {}

   105

        # copy PluginMethods so that it can be later customized

   106

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

   107

        self.LoadSTLibrary()

   108

   109

    def PluginBaseXmlFilePath(self, PlugName=None):

   110

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

   111

   112

    def PluginXmlFilePath(self, PlugName=None):

   113

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

   114

   115

    def PluginLibraryFilePath(self):

   116

        return os.path.join(self.PluginPath(), "pous.xml")

   117

   118

    def PluginPath(self):

   119

        return os.path.join(self.PlugParent.PluginPath(), self.PlugType)

   120

   121

    def PlugPath(self,PlugName=None):

   122

        if not PlugName:

   123

            PlugName = self.BaseParams.getName()

   124

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

   125

                            PlugName + NameTypeSeparator + self.PlugType)

   126

   127

    def PlugTestModified(self):

   128

        return self.ChangesToSave

   129

   130

    def ProjectTestModified(self):

   131

        """

   132

        recursively check modified status

   133

        """

   134

        if self.PlugTestModified():

   135

            return True

   136

   137

        for PlugChild in self.IterChilds():

   138

            if PlugChild.ProjectTestModified():

   139

                return True

   140

   141

        return False

   142

   143

    def OnPlugSave(self):

   144

        #Default, do nothing and return success

   145

        return True

   146

   147

    def GetParamsAttributes(self, path = None):

   148

        if path:

   149

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

   150

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

   151

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

   152

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

   153

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

   154

        else:

   155

            params = []

   156

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

   157

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

   158

            if self.PlugParams:

   159

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

   160

            return params

   161

   162

    def SetParamsAttribute(self, path, value):

   163

        self.ChangesToSave = True

   164

        # Filter IEC_Channel and Name, that have specific behavior

   165

        if path == "BaseParams.IEC_Channel":

   166

            return self.FindNewIEC_Channel(value), True

   167

        elif path == "BaseParams.Name":

   168

            res = self.FindNewName(value)

   169

            self.PlugRequestSave()

   170

            return res, True

   171

   172

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

   173

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

   174

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

   175

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

   176

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

   177

        return value, False

   178

   179

    def PlugMakeDir(self):

   180

        os.mkdir(self.PlugPath())

   181

   182

    def PlugRequestSave(self):

   183

        # If plugin do not have corresponding directory

   184

        plugpath = self.PlugPath()

   185

        if not os.path.isdir(plugpath):

   186

            # Create it

   187

            os.mkdir(plugpath)

   188

   189

        # generate XML for base XML parameters controller of the plugin

   190

        if self.MandatoryParams:

   191

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

   192

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

   193

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

   194

            BaseXMLFile.close()

   195

   196

        # generate XML for XML parameters controller of the plugin

   197

        if self.PlugParams:

   198

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

   199

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

   200

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

   201

            XMLFile.close()

   202

   203

        # Call the plugin specific OnPlugSave method

   204

        result = self.OnPlugSave()

   205

        if not result:

   206

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

   207

   208

        # mark plugin as saved

   209

        self.ChangesToSave = False        

   210

        # go through all childs and do the same

   211

        for PlugChild in self.IterChilds():

   212

            result = PlugChild.PlugRequestSave()

   213

            if result:

   214

                return result

   215

        return None

   216

   217

    def PlugImport(self, src_PlugPath):

   218

        shutil.copytree(src_PlugPath, self.PlugPath)

   219

        return True

   220

   221

    def PlugGenerate_C(self, buildpath, locations):

   222

        """

   223

        Generate C code

   224

        @param locations: List of complete variables locations \

   225

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

   226

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

   227

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

   228

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

   229

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

   230

            }, ...]

   231

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

   232

        """

   233

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

   234

        return [],"",False

   235

   236

    def _Generate_C(self, buildpath, locations):

   237

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

   238

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

   239

        gen_result = self.PlugGenerate_C(buildpath, locations)

   240

        PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = gen_result[:3]

   241

        extra_files = gen_result[3:]

   242

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

   243

        if PlugCFilesAndCFLAGS:

   244

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

   245

        else:

   246

            LocationCFilesAndCFLAGS = []

   247

   248

        # plugin asks for some LDFLAGS

   249

        if PlugLDFLAGS:

   250

            # LDFLAGS can be either string

   251

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

   252

                LDFLAGS=[PlugLDFLAGS]

   253

            #or list of strings

   254

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

   255

                LDFLAGS=PlugLDFLAGS[:]

   256

        else:

   257

            LDFLAGS=[]

   258

   259

        # recurse through all childs, and stack their results

   260

        for PlugChild in self.IECSortedChilds():

   261

            new_location = PlugChild.GetCurrentLocation()

   262

            # How deep are we in the tree ?

   263

            depth=len(new_location)

   264

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   265

                PlugChild._Generate_C(

   266

                    #keep the same path

   267

                    buildpath,

   268

                    # filter locations that start with current IEC location

   269

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

   270

            # stack the result

   271

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   272

            LDFLAGS += _LDFLAGS

   273

            extra_files += _extra_files

   274

   275

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   276

   277

    def BlockTypesFactory(self):

   278

        if self.LibraryControler is not None:

   279

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

   280

        return []

   281

   282

    def ParentsBlockTypesFactory(self):

   283

        return self.PlugParent.ParentsBlockTypesFactory() + self.BlockTypesFactory()

   284

   285

    def PluginsBlockTypesFactory(self):

   286

        list = self.BlockTypesFactory()

   287

        for PlugChild in self.IterChilds():

   288

            list += PlugChild.PluginsBlockTypesFactory()

   289

        return list

   290

   291

    def STLibraryFactory(self):

   292

        if self.LibraryControler is not None:

   293

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

   294

            return program + "\n"

   295

        return ""

   296

   297

    def PluginsSTLibraryFactory(self):

   298

        program = self.STLibraryFactory()

   299

        for PlugChild in self.IECSortedChilds():

   300

            program += PlugChild.PluginsSTLibraryFactory()

   301

        return program

   302

   303

    def IterChilds(self):

   304

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

   305

            for PlugInstance in PluggedChilds:

   306

                yield PlugInstance

   307

   308

    def IECSortedChilds(self):

   309

        # reorder childs by IEC_channels

   310

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

   311

        if ordered:

   312

            ordered.sort()

   313

            return zip(*ordered)[1]

   314

        else:

   315

            return []

   316

   317

    def _GetChildBySomething(self, something, toks):

   318

        for PlugInstance in self.IterChilds():

   319

            # if match component of the name

   320

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

   321

                # if Name have other components

   322

                if len(toks) >= 2:

   323

                    # Recurse in order to find the latest object

   324

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

   325

                # No sub name -> found

   326

                return PlugInstance

   327

        # Not found

   328

        return None

   329

   330

    def GetChildByName(self, Name):

   331

        if Name:

   332

            toks = Name.split('.')

   333

            return self._GetChildBySomething("Name", toks)

   334

        else:

   335

            return self

   336

   337

    def GetChildByIECLocation(self, Location):

   338

        if Location:

   339

            return self._GetChildBySomething("IEC_Channel", Location)

   340

        else:

   341

            return self

   342

   343

    def GetCurrentLocation(self):

   344

        """

   345

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

   346

        """

   347

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

   348

   349

    def GetCurrentName(self):

   350

        """

   351

        @return:  String "ParentParentName.ParentName.Name"

   352

        """

   353

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

   354

   355

    def _GetCurrentName(self):

   356

        """

   357

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

   358

        """

   359

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

   360

   361

    def GetPlugRoot(self):

   362

        return self.PlugParent.GetPlugRoot()

   363

   364

    def GetFullIEC_Channel(self):

   365

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

   366

   367

    def GetLocations(self):

   368

        location = self.GetCurrentLocation()

   369

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

   370

   371

    def GetPlugInfos(self):

   372

        childs = []

   373

        # reorder childs by IEC_channels

   374

        for child in self.IECSortedChilds():

   375

            childs.append(child.GetPlugInfos())

   376

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

   377

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

   378

        else:

   379

            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}

   380

   381

    def FindNewName(self, DesiredName):

   382

        """

   383

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

   384

        @param DesiredName: The desired Name (string)

   385

        """

   386

        # Get Current Name

   387

        CurrentName = self.BaseParams.getName()

   388

        # Do nothing if no change

   389

        #if CurrentName == DesiredName: return CurrentName

   390

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

   391

        AllNames=[]

   392

        for PlugInstance in self.PlugParent.IterChilds():

   393

            if PlugInstance != self:

   394

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

   395

   396

        # Find a free name, eventually appending digit

   397

        res = DesiredName

   398

        suffix = 1

   399

        while res in AllNames:

   400

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

   401

            suffix += 1

   402

   403

        # Get old path

   404

        oldname = self.PlugPath()

   405

        # Check previous plugin existance

   406

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

   407

        # Set the new name

   408

        self.BaseParams.setName(res)

   409

        # Rename plugin dir if exist

   410

        if not dontexist:

   411

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

   412

        # warn user he has two left hands

   413

        if DesiredName != res:

   414

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

   415

        return res

   416

   417

    def FindNewIEC_Channel(self, DesiredChannel):

   418

        """

   419

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

   420

        @param DesiredChannel: The desired IEC channel (int)

   421

        """

   422

        # Get Current IEC channel

   423

        CurrentChannel = self.BaseParams.getIEC_Channel()

   424

        # Do nothing if no change

   425

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   426

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

   427

        AllChannels=[]

   428

        for PlugInstance in self.PlugParent.IterChilds():

   429

            if PlugInstance != self:

   430

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

   431

        AllChannels.sort()

   432

   433

        # Now, try to guess the nearest available channel

   434

        res = DesiredChannel

   435

        while res in AllChannels: # While channel not free

   436

            if res < CurrentChannel: # Want to go down ?

   437

                res -=  1 # Test for n-1

   438

                if res < 0 :

   439

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

   440

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

   441

            else : # Want to go up ?

   442

                res +=  1 # Test for n-1

   443

        # Finally set IEC Channel

   444

        self.BaseParams.setIEC_Channel(res)

   445

        if DesiredChannel != res:

   446

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

   447

        return res

   448

   449

    def OnPlugClose(self):

   450

        return True

   451

   452

    def _doRemoveChild(self, PlugInstance):

   453

        # Remove all childs of child

   454

        for SubPlugInstance in PlugInstance.IterChilds():

   455

            PlugInstance._doRemoveChild(SubPlugInstance)

   456

        # Call the OnCloseMethod

   457

        PlugInstance.OnPlugClose()

   458

        # Delete plugin dir

   459

        shutil.rmtree(PlugInstance.PlugPath())

   460

        # Remove child of PluggedChilds

   461

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

   462

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

   463

   464

    def PlugRemove(self):

   465

        # Fetch the plugin

   466

        #PlugInstance = self.GetChildByName(PlugName)

   467

        # Ask to his parent to remove it

   468

        self.PlugParent._doRemoveChild(self)

   469

   470

    def PlugAddChild(self, PlugName, PlugType):

   471

        """

   472

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

   473

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

   474

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

   475

        """

   476

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

   477

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

   478

        transpose = zip(*self.PlugChildsTypes)

   479

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

   480

        # Check that adding this plugin is allowed

   481

        try:

   482

            PlugClass, PlugHelp = PlugChildsTypes[PlugType]

   483

        except KeyError:

   484

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

   485