1

"""

     2

Base definitions for beremiz plugins

     3

"""

     4

     5

import os,sys,traceback

     6

import time

     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 xmlclass import GenerateClassesFromXSDstring

    17

from wxPopen import ProcessLogger

    18

    19

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

    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 GetDataTypes(self, tagname = "", basetypes = True, only_locatables = False, debug = False):

    62

        return []

    63

    64

    def GetEnumeratedDataValues(self, debug = False):

    65

        return []

    66

    67

    def StartBuffering(self):

    68

        pass

    69

    70

    def EndBuffering(self):

    71

        pass

    72

    73

    def BufferProject(self):

    74

        pass

    75

    76

# helper func to get path to images

    77

def opjimg(imgname):

    78

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

    79

    80

# helper func to check path write permission

    81

def CheckPathPerm(path):

    82

    if path is None or not os.path.isdir(path):

    83

        return False

    84

    for root, dirs, files in os.walk(path):

    85

         for name in files:

    86

             if os.access(root, os.W_OK) is not True or os.access(os.path.join(root, name), os.W_OK) is not True:

    87

                 return False

    88

    return True

    89

    90

class PlugTemplate:

    91

    """

    92

    This class is the one that define plugins.

    93

    """

    94

    95

    XSD = None

    96

    PlugChildsTypes = []

    97

    PlugMaxCount = None

    98

    PluginMethods = []

    99

    LibraryControler = None

   100

    EditorType = None

   101

   102

    def _AddParamsMembers(self):

   103

        self.PlugParams = None

   104

        if self.XSD:

   105

            self.Classes = GenerateClassesFromXSDstring(self.XSD)

   106

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

   107

            if len(Classes) == 1:

   108

                name, XSDclass = Classes[0]

   109

                obj = XSDclass()

   110

                self.PlugParams = (name, obj)

   111

                setattr(self, name, obj)

   112

   113

    def __init__(self):

   114

        # Create BaseParam 

   115

        self.BaseParams = _BaseParamsClass()

   116

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

   117

        self._AddParamsMembers()

   118

        self.PluggedChilds = {}

   119

        self._View = None

   120

        # copy PluginMethods so that it can be later customized

   121

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

   122

        self.LoadSTLibrary()

   123

   124

    def PluginBaseXmlFilePath(self, PlugName=None):

   125

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

   126

   127

    def PluginXmlFilePath(self, PlugName=None):

   128

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

   129

   130

    def PluginLibraryFilePath(self):

   131

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

   132

   133

    def PluginPath(self):

   134

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

   135

   136

    def PlugPath(self,PlugName=None):

   137

        if not PlugName:

   138

            PlugName = self.PlugName()

   139

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

   140

                            PlugName + NameTypeSeparator + self.PlugType)

   141

   142

    def PlugName(self):

   143

        return self.BaseParams.getName()

   144

   145

    def PlugEnabled(self):

   146

        return self.BaseParams.getEnabled()

   147

   148

    def PlugFullName(self):

   149

        parent = self.PlugParent.PlugFullName()

   150

        if parent != "":

   151

            return parent + "." + self.PlugName()

   152

        return self.BaseParams.getName()

   153

   154

    def GetIconPath(self, name):

   155

        return opjimg(name)

   156

   157

    def PlugTestModified(self):

   158

        return self.ChangesToSave

   159

   160

    def ProjectTestModified(self):

   161

        """

   162

        recursively check modified status

   163

        """

   164

        if self.PlugTestModified():

   165

            return True

   166

   167

        for PlugChild in self.IterChilds():

   168

            if PlugChild.ProjectTestModified():

   169

                return True

   170

   171

        return False

   172

   173

    def OnPlugSave(self):

   174

        #Default, do nothing and return success

   175

        return True

   176

   177

    def GetParamsAttributes(self, path = None):

   178

        if path:

   179

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

   180

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

   181

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

   182

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

   183

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

   184

        else:

   185

            params = []

   186

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

   187

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

   188

            if self.PlugParams:

   189

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

   190

            return params

   191

   192

    def SetParamsAttribute(self, path, value):

   193

        self.ChangesToSave = True

   194

        # Filter IEC_Channel and Name, that have specific behavior

   195

        if path == "BaseParams.IEC_Channel":

   196

            old_leading = ".".join(map(str, self.GetCurrentLocation()))

   197

            new_value = self.FindNewIEC_Channel(value)

   198

            new_leading = ".".join(map(str, self.PlugParent.GetCurrentLocation() + (new_value,)))

   199

            self.GetPlugRoot().UpdateProjectVariableLocation(old_leading, new_leading)

   200

            return new_value, True

   201

        elif path == "BaseParams.Name":

   202

            res = self.FindNewName(value)

   203

            self.PlugRequestSave()

   204

            return res, True

   205

   206

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

   207

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

   208

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

   209

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

   210

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

   211

        return value, False

   212

   213

    def PlugMakeDir(self):

   214

        os.mkdir(self.PlugPath())

   215

   216

    def PlugRequestSave(self):

   217

        if self.GetPlugRoot().CheckProjectPathPerm(False):

   218

            # If plugin do not have corresponding directory

   219

            plugpath = self.PlugPath()

   220

            if not os.path.isdir(plugpath):

   221

                # Create it

   222

                os.mkdir(plugpath)

   223

   224

            # generate XML for base XML parameters controller of the plugin

   225

            if self.MandatoryParams:

   226

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

   227

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

   228

                BaseXMLFile.write(self.MandatoryParams[1].generateXMLText(self.MandatoryParams[0], 0).encode("utf-8"))

   229

                BaseXMLFile.close()

   230

   231

            # generate XML for XML parameters controller of the plugin

   232

            if self.PlugParams:

   233

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

   234

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

   235

                XMLFile.write(self.PlugParams[1].generateXMLText(self.PlugParams[0], 0).encode("utf-8"))

   236

                XMLFile.close()

   237

   238

            # Call the plugin specific OnPlugSave method

   239

            result = self.OnPlugSave()

   240

            if not result:

   241

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

   242

   243

            # mark plugin as saved

   244

            self.ChangesToSave = False

   245

            # go through all childs and do the same

   246

            for PlugChild in self.IterChilds():

   247

                result = PlugChild.PlugRequestSave()

   248

                if result:

   249

                    return result

   250

        return None

   251

   252

    def PlugImport(self, src_PlugPath):

   253

        shutil.copytree(src_PlugPath, self.PlugPath)

   254

        return True

   255

   256

    def PlugGenerate_C(self, buildpath, locations):

   257

        """

   258

        Generate C code

   259

        @param locations: List of complete variables locations \

   260

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

   261

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

   262

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

   263

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

   264

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

   265

            }, ...]

   266

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

   267

        """

   268

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

   269

        return [],"",False

   270

   271

    def _Generate_C(self, buildpath, locations):

   272

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

   273

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

   274

        gen_result = self.PlugGenerate_C(buildpath, locations)

   275

        PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = gen_result[:3]

   276

        extra_files = gen_result[3:]

   277

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

   278

        if PlugCFilesAndCFLAGS:

   279

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

   280

        else:

   281

            LocationCFilesAndCFLAGS = []

   282

   283

        # plugin asks for some LDFLAGS

   284

        if PlugLDFLAGS:

   285

            # LDFLAGS can be either string

   286

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

   287

                LDFLAGS=[PlugLDFLAGS]

   288

            #or list of strings

   289

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

   290

                LDFLAGS=PlugLDFLAGS[:]

   291

        else:

   292

            LDFLAGS=[]

   293

   294

        # recurse through all childs, and stack their results

   295

        for PlugChild in self.IECSortedChilds():

   296

            new_location = PlugChild.GetCurrentLocation()

   297

            # How deep are we in the tree ?

   298

            depth=len(new_location)

   299

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   300

                PlugChild._Generate_C(

   301

                    #keep the same path

   302

                    buildpath,

   303

                    # filter locations that start with current IEC location

   304

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

   305

            # stack the result

   306

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   307

            LDFLAGS += _LDFLAGS

   308

            extra_files += _extra_files

   309

   310

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   311

   312

    def PluginTypesFactory(self):

   313

        if self.LibraryControler is not None:

   314

            return [{"name" : self.PlugType, "types": self.LibraryControler.Project}]

   315

        return []

   316

   317

    def ParentsTypesFactory(self):

   318

        return self.PlugParent.ParentsTypesFactory() + self.PluginTypesFactory()

   319

   320

    def PluginsTypesFactory(self):

   321

        list = self.PluginTypesFactory()

   322

        for PlugChild in self.IterChilds():

   323

            list += PlugChild.PluginsTypesFactory()

   324

        return list

   325

   326

    def STLibraryFactory(self):

   327

        if self.LibraryControler is not None:

   328

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

   329

            return program + "\n"

   330

        return ""

   331

   332

    def PluginsSTLibraryFactory(self):

   333

        program = self.STLibraryFactory()

   334

        for PlugChild in self.IECSortedChilds():

   335

            program += PlugChild.PluginsSTLibraryFactory()

   336

        return program

   337

   338

    def IterChilds(self):

   339

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

   340

            for PlugInstance in PluggedChilds:

   341

                yield PlugInstance

   342

   343

    def IECSortedChilds(self):

   344

        # reorder childs by IEC_channels

   345

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

   346

        if ordered:

   347

            ordered.sort()

   348

            return zip(*ordered)[1]

   349

        else:

   350

            return []

   351

   352

    def _GetChildBySomething(self, something, toks):

   353

        for PlugInstance in self.IterChilds():

   354

            # if match component of the name

   355

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

   356

                # if Name have other components

   357

                if len(toks) >= 2:

   358

                    # Recurse in order to find the latest object

   359

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

   360

                # No sub name -> found

   361

                return PlugInstance

   362

        # Not found

   363

        return None

   364

   365

    def GetChildByName(self, Name):

   366

        if Name:

   367

            toks = Name.split('.')

   368

            return self._GetChildBySomething("Name", toks)

   369

        else:

   370

            return self

   371

   372

    def GetChildByIECLocation(self, Location):

   373

        if Location:

   374

            return self._GetChildBySomething("IEC_Channel", Location)

   375

        else:

   376

            return self

   377

   378

    def GetCurrentLocation(self):

   379

        """

   380

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

   381

        """

   382

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

   383

   384

    def GetCurrentName(self):

   385

        """

   386

        @return:  String "ParentParentName.ParentName.Name"

   387

        """

   388

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

   389

   390

    def _GetCurrentName(self):

   391

        """

   392

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

   393

        """

   394

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

   395

   396

    def GetPlugRoot(self):

   397

        return self.PlugParent.GetPlugRoot()

   398

   399

    def GetFullIEC_Channel(self):

   400

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

   401

   402

    def GetLocations(self):

   403

        location = self.GetCurrentLocation()

   404

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

   405

   406

    def GetVariableLocationTree(self):

   407

        '''

   408

        This function is meant to be overridden by plugins.

   409

   410

        It should returns an list of dictionaries

   411

   412

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

   413

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

   414

        '''

   415

        children = []

   416

        for child in self.IECSortedChilds():

   417

            children.append(child.GetVariableLocationTree())

   418

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

   419

                "type": LOCATION_PLUGIN,

   420

                "location": self.GetFullIEC_Channel(),

   421

                "children": children}

   422

   423

    def GetPlugInfos(self):

   424

        childs = []

   425

        # reorder childs by IEC_channels

   426

        for child in self.IECSortedChilds():

   427

            childs.append(child.GetPlugInfos())

   428

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

   429

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

   430

        else:

   431

            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}

   432

   433

    def FindNewName(self, DesiredName):

   434

        """

   435

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

   436

        @param DesiredName: The desired Name (string)

   437

        """

   438

        # Get Current Name

   439

        CurrentName = self.BaseParams.getName()

   440

        # Do nothing if no change

   441

        #if CurrentName == DesiredName: return CurrentName

   442

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

   443

        AllNames=[]

   444

        for PlugInstance in self.PlugParent.IterChilds():

   445

            if PlugInstance != self:

   446

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

   447

   448

        # Find a free name, eventually appending digit

   449

        res = DesiredName

   450

        suffix = 1

   451

        while res in AllNames:

   452

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

   453

            suffix += 1

   454

   455

        # Get old path

   456

        oldname = self.PlugPath()

   457

        # Check previous plugin existance

   458

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

   459

        # Set the new name

   460

        self.BaseParams.setName(res)

   461

        # Rename plugin dir if exist

   462

        if not dontexist:

   463

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

   464

        # warn user he has two left hands

   465

        if DesiredName != res:

   466

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

   467

        return res

   468

   469

    def GetAllChannels(self):

   470

        AllChannels=[]

   471

        for PlugInstance in self.PlugParent.IterChilds():

   472

            if PlugInstance != self:

   473

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

   474

        AllChannels.sort()

   475

        return AllChannels

   476

   477

    def FindNewIEC_Channel(self, DesiredChannel):

   478

        """

   479

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

   480

        @param DesiredChannel: The desired IEC channel (int)

   481

        """

   482

        # Get Current IEC channel

   483

        CurrentChannel = self.BaseParams.getIEC_Channel()

   484

        # Do nothing if no change

   485

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   486