1

"""

     2

Base definitions for beremiz plugins

     3

"""

     4

     5

import os,sys,traceback

     7

import plugins

     8

import types

     9

import shutil

    10

from xml.dom import minidom

    11

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

    16

from docpdf import *

    17

from xmlclass import GenerateClassesFromXSDstring

    18

from wxPopen import ProcessLogger

    19

    20

from PLCControler import PLCControler, LOCATION_PLUGIN, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    21

    22

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

    23

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

    24

          <xsd:element name="BaseParams">

    25

            <xsd:complexType>

    26

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

    27

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

    28

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

    29

            </xsd:complexType>

    30

          </xsd:element>

    31

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

    32

    33

NameTypeSeparator = '@'

    34

    35

class MiniTextControler:

    36

    37

    def __init__(self, filepath):

    38

        self.FilePath = filepath

    39

    40

    def SetEditedElementText(self, tagname, text):

    41

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

    42

        file.write(text)

    43

        file.close()

    44

    45

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

    46

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

    47

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

    48

            text = file.read()

    49

            file.close()

    50

            return text

    51

        return ""

    52

    53

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

    54

        return []

    55

    56

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

    57

        return "program"

    58

    59

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

    60

        return []

    61

    62

    def GetEnumeratedDataValues(self, debug = False):

    63

        return []

    64

    65

    def StartBuffering(self):

    66

        pass

    67

    68

    def EndBuffering(self):

    69

        pass

    70

    71

    def BufferProject(self):

    72

        pass

    73

    74

# helper func to get path to images

    75

def opjimg(imgname):

    76

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

    77

    78

class PlugTemplate:

    79

    """

    80

    This class is the one that define plugins.

    81

    """

    82

    83

    XSD = None

    84

    PlugChildsTypes = []

    85

    PlugMaxCount = None

    86

    PluginMethods = []

    87

    LibraryControler = None

    88

    89

    def _AddParamsMembers(self):

    90

        self.PlugParams = None

    91

        if self.XSD:

    94

            if len(Classes) == 1:

    95

                name, XSDclass = Classes[0]

    96

                obj = XSDclass()

    97

                self.PlugParams = (name, obj)

    98

                setattr(self, name, obj)

    99

   100

    def __init__(self):

   101

        # Create BaseParam 

   102

        self.BaseParams = _BaseParamsClass()

   103

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

   104

        self._AddParamsMembers()

   105

        self.PluggedChilds = {}

   106

        # copy PluginMethods so that it can be later customized

   107

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

   108

        self.LoadSTLibrary()

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

   117

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

   118

   119

    def PluginPath(self):

   120

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

   121

   122

    def PlugPath(self,PlugName=None):

   123

        if not PlugName:

   124

            PlugName = self.BaseParams.getName()

   125

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

   126

                            PlugName + NameTypeSeparator + self.PlugType)

   127

   128

    def PlugTestModified(self):

   129

        return self.ChangesToSave

   130

   131

    def ProjectTestModified(self):

   132

        """

   133

        recursively check modified status

   134

        """

   135

        if self.PlugTestModified():

   136

            return True

   137

   138

        for PlugChild in self.IterChilds():

   139

            if PlugChild.ProjectTestModified():

   140

                return True

   141

   142

        return False

   143

   144

    def OnPlugSave(self):

   145

        #Default, do nothing and return success

   146

        return True

   147

   148

    def GetParamsAttributes(self, path = None):

   149

        if path:

   150

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

   151

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

   152

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

   153

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

   154

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

   155

        else:

   156

            params = []

   157

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

   158

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

   159

            if self.PlugParams:

   160

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

   161

            return params

   162

   163

    def SetParamsAttribute(self, path, value):

   164

        self.ChangesToSave = True

   165

        # Filter IEC_Channel and Name, that have specific behavior

   166

        if path == "BaseParams.IEC_Channel":

   167

            return self.FindNewIEC_Channel(value), True

   168

        elif path == "BaseParams.Name":

   169

            res = self.FindNewName(value)

   170

            self.PlugRequestSave()

   171

            return res, True

   172

   173

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

   174

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

   175

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

   176

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

   177

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

   178

        return value, False

   179

   180

    def PlugMakeDir(self):

   181

        os.mkdir(self.PlugPath())

   182

   183

    def PlugRequestSave(self):

   184

        # If plugin do not have corresponding directory

   185

        plugpath = self.PlugPath()

   186

        if not os.path.isdir(plugpath):

   187

            # Create it

   188

            os.mkdir(plugpath)

   189

   190

        # generate XML for base XML parameters controller of the plugin

   191

        if self.MandatoryParams:

   192

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

   193

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

   194

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

   195

            BaseXMLFile.close()

   196

   197

        # generate XML for XML parameters controller of the plugin

   198

        if self.PlugParams:

   199

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

   200

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

   201

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

   202

            XMLFile.close()

   203

   204

        # Call the plugin specific OnPlugSave method

   205

        result = self.OnPlugSave()

   206

        if not result:

   207

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

   208

   209

        # mark plugin as saved

   210

        self.ChangesToSave = False        

   211

        # go through all childs and do the same

   212

        for PlugChild in self.IterChilds():

   213

            result = PlugChild.PlugRequestSave()

   214

            if result:

   215

                return result

   216

        return None

   217

   218

    def PlugImport(self, src_PlugPath):

   219

        shutil.copytree(src_PlugPath, self.PlugPath)

   220

        return True

   221

   222

    def PlugGenerate_C(self, buildpath, locations):

   223

        """

   224

        Generate C code

   225

        @param locations: List of complete variables locations \

   226

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

   227

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

   228

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

   229

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

   230

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

   231

            }, ...]

   232

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

   233

        """

   234

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

   235

        return [],"",False

   236

   237

    def _Generate_C(self, buildpath, locations):

   238

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

   239

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

   240

        gen_result = self.PlugGenerate_C(buildpath, locations)

   241

        PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = gen_result[:3]

   242

        extra_files = gen_result[3:]

   243

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

   244

        if PlugCFilesAndCFLAGS:

   245

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

   246

        else:

   247

            LocationCFilesAndCFLAGS = []

   248

   249

        # plugin asks for some LDFLAGS

   250

        if PlugLDFLAGS:

   251

            # LDFLAGS can be either string

   252

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

   253

                LDFLAGS=[PlugLDFLAGS]

   254

            #or list of strings

   255

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

   256

                LDFLAGS=PlugLDFLAGS[:]

   257

        else:

   258

            LDFLAGS=[]

   259

   260

        # recurse through all childs, and stack their results

   261

        for PlugChild in self.IECSortedChilds():

   262

            new_location = PlugChild.GetCurrentLocation()

   263

            # How deep are we in the tree ?

   264

            depth=len(new_location)

   265

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   266

                PlugChild._Generate_C(

   267

                    #keep the same path

   268

                    buildpath,

   269

                    # filter locations that start with current IEC location

   270

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

   271

            # stack the result

   272

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   273

            LDFLAGS += _LDFLAGS

   274

            extra_files += _extra_files

   275

   276

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   277

   278

    def BlockTypesFactory(self):

   279

        if self.LibraryControler is not None:

   280

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

   281

        return []

   282

   283

    def ParentsBlockTypesFactory(self):

   284

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

   285

   286

    def PluginsBlockTypesFactory(self):

   287

        list = self.BlockTypesFactory()

   288

        for PlugChild in self.IterChilds():

   289

            list += PlugChild.PluginsBlockTypesFactory()

   290

        return list

   291

   292

    def STLibraryFactory(self):

   293

        if self.LibraryControler is not None:

   294

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

   295

            return program + "\n"

   296

        return ""

   297

   298

    def PluginsSTLibraryFactory(self):

   299

        program = self.STLibraryFactory()

   300

        for PlugChild in self.IECSortedChilds():

   301

            program += PlugChild.PluginsSTLibraryFactory()

   302

        return program

   303

   304

    def IterChilds(self):

   305

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

   306

            for PlugInstance in PluggedChilds:

   307

                yield PlugInstance

   308

   309

    def IECSortedChilds(self):

   310

        # reorder childs by IEC_channels

   311

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

   312

        if ordered:

   313

            ordered.sort()

   314

            return zip(*ordered)[1]

   315

        else:

   316

            return []

   317

   318

    def _GetChildBySomething(self, something, toks):

   319

        for PlugInstance in self.IterChilds():

   320

            # if match component of the name

   321

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

   322

                # if Name have other components

   323

                if len(toks) >= 2:

   324

                    # Recurse in order to find the latest object

   325

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

   326

                # No sub name -> found

   327

                return PlugInstance

   328

        # Not found

   329

        return None

   330

   331

    def GetChildByName(self, Name):

   332

        if Name:

   333

            toks = Name.split('.')

   334

            return self._GetChildBySomething("Name", toks)

   335

        else:

   336

            return self

   337

   338

    def GetChildByIECLocation(self, Location):

   339

        if Location:

   340

            return self._GetChildBySomething("IEC_Channel", Location)

   341

        else:

   342

            return self

   343

   344

    def GetCurrentLocation(self):

   345

        """

   346

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

   347

        """

   348

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

   349

   350

    def GetCurrentName(self):

   351

        """

   352

        @return:  String "ParentParentName.ParentName.Name"

   353

        """

   354

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

   355

   356

    def _GetCurrentName(self):

   357

        """

   358

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

   359

        """

   360

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

   361

   362

    def GetPlugRoot(self):

   363

        return self.PlugParent.GetPlugRoot()

   364

   365

    def GetFullIEC_Channel(self):

   366

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

   367

   368

    def GetLocations(self):

   369

        location = self.GetCurrentLocation()

   370

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

   371

   372

    def GetVariableLocationTree(self):

   373

        '''

   374

        This function is meant to be overridden by plugins.

   375

   376

        It should returns an list of dictionaries

   377

   378

        - IEC_type is an IEC type like BOOL/BYTE/SINT/...

   379

        - location is a string of this variable's location, like "%IX0.0.0"

   380

        '''

   381

        children = []

   382

        for child in self.IECSortedChilds():

   383

            children.append(child.GetVariableLocationTree())

   384

        return {"name": self.BaseParams.getName(),

   385

                "type": LOCATION_PLUGIN,

   386

                "location": self.GetFullIEC_Channel(),

   387

                "children": children}

   388

   389

    def GetPlugInfos(self):

   390

        childs = []

   391

        # reorder childs by IEC_channels

   392

        for child in self.IECSortedChilds():

   393

            childs.append(child.GetPlugInfos())

   394

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

   395

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

   396

        else:

   397

            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}

   398

   399

    def FindNewName(self, DesiredName):

   400

        """

   401

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

   402

        @param DesiredName: The desired Name (string)

   403

        """

   404

        # Get Current Name

   405

        CurrentName = self.BaseParams.getName()

   406

        # Do nothing if no change

   407

        #if CurrentName == DesiredName: return CurrentName

   408

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

   409

        AllNames=[]

   410

        for PlugInstance in self.PlugParent.IterChilds():

   411

            if PlugInstance != self:

   412

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

   413

   414

        # Find a free name, eventually appending digit

   415

        res = DesiredName

   416

        suffix = 1

   417

        while res in AllNames:

   418

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

   419

            suffix += 1

   420

   421

        # Get old path

   422

        oldname = self.PlugPath()

   423

        # Check previous plugin existance

   424

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

   425

        # Set the new name

   426

        self.BaseParams.setName(res)

   427

        # Rename plugin dir if exist

   428

        if not dontexist:

   429

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

   430

        # warn user he has two left hands

   431

        if DesiredName != res:

   432

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

   433

        return res

   434

   435

    def FindNewIEC_Channel(self, DesiredChannel):

   436

        """

   437

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

   438

        @param DesiredChannel: The desired IEC channel (int)

   439

        """

   440

        # Get Current IEC channel

   441

        CurrentChannel = self.BaseParams.getIEC_Channel()

   442

        # Do nothing if no change

   443

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   444

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

   445

        AllChannels=[]

   446

        for PlugInstance in self.PlugParent.IterChilds():

   447

            if PlugInstance != self:

   448

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

   449

        AllChannels.sort()

   450

   451

        # Now, try to guess the nearest available channel

   452

        res = DesiredChannel

   453

        while res in AllChannels: # While channel not free

   454

            if res < CurrentChannel: # Want to go down ?

   455

                res -=  1 # Test for n-1

   456

                if res < 0 :

   457

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

   458

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

   459

            else : # Want to go up ?

   460

                res +=  1 # Test for n-1

   461

        # Finally set IEC Channel

   462

        self.BaseParams.setIEC_Channel(res)

   463

        if DesiredChannel != res:

   464

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

   465

        return res

   466

   467

    def OnPlugClose(self):

   468

        return True

   469

   470

    def _doRemoveChild(self, PlugInstance):

   471

        # Remove all childs of child

   472

        for SubPlugInstance in PlugInstance.IterChilds():

   473

            PlugInstance._doRemoveChild(SubPlugInstance)

   474

        # Call the OnCloseMethod

   475

        PlugInstance.OnPlugClose()

   476

        # Delete plugin dir

   477

        shutil.rmtree(PlugInstance.PlugPath())

   478

        # Remove child of PluggedChilds

   479

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

   480

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

   481

   482

    def PlugRemove(self):

   483

        # Fetch the plugin

   484

        #PlugInstance = self.GetChildByName(PlugName)

   485

        # Ask to his parent to remove it