1

"""

     2

Base definitions for beremiz confnodes

     3

"""

     4

     5

import os,sys,traceback

     6

import time

     7

import confnodes

     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_CONFNODE, 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 CTNFullName(self):

    40

        return ""

    41

    42

    def SetEditedElementText(self, tagname, text):

    43

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

    44

        file.write(text)

    45

        file.close()

    46

    47

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

    48

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

    49

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

    50

            text = file.read()

    51

            file.close()

    52

            return text

    53

        return ""

    54

    55

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

    56

        return []

    57

    58

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

    59

        return "program"

    60

    61

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

    62

        return []

    63

    64

    def GetDataTypes(self, tagname = "", basetypes = True, only_locatables = False, debug = False):

    65

        return []

    66

    67

    def GetEnumeratedDataValues(self, debug = False):

    68

        return []

    69

    70

    def StartBuffering(self):

    71

        pass

    72

    73

    def EndBuffering(self):

    74

        pass

    75

    76

    def BufferProject(self):

    77

        pass

    78

    79

# helper func to get path to images

    80

def opjimg(imgname):

    81

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

    82

    83

# helper func to check path write permission

    84

def CheckPathPerm(path):

    85

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

    86

        return False

    87

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

    88

         for name in files:

    89

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

    90

                 return False

    91

    return True

    92

    93

class ConfigTreeNode:

    94

    """

    95

    This class is the one that define confnodes.

    96

    """

    97

    98

    XSD = None

    99

    CTNChildrenTypes = []

   100

    CTNMaxCount = None

   101

    ConfNodeMethods = []

   102

    LibraryControler = None

   103

    EditorType = None

   104

   105

    def _AddParamsMembers(self):

   106

        self.CTNParams = None

   107

        if self.XSD:

   108

            self.Classes = GenerateClassesFromXSDstring(self.XSD)

   109

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

   110

            if len(Classes) == 1:

   111

                name, XSDclass = Classes[0]

   112

                obj = XSDclass()

   113

                self.CTNParams = (name, obj)

   114

                setattr(self, name, obj)

   115

   116

    def __init__(self):

   117

        # Create BaseParam 

   118

        self.BaseParams = _BaseParamsClass()

   119

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

   120

        self._AddParamsMembers()

   121

        self.Children = {}

   122

        self._View = None

   123

        # copy ConfNodeMethods so that it can be later customized

   124

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

   125

        self.LoadSTLibrary()

   126

   127

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

   128

        return os.path.join(self.CTNPath(CTNName), "baseconfnode.xml")

   129

   130

    def ConfNodeXmlFilePath(self, CTNName=None):

   131

        return os.path.join(self.CTNPath(CTNName), "confnode.xml")

   132

   133

    def ConfNodeLibraryFilePath(self):

   134

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

   135

   136

    def ConfNodePath(self):

   137

        return os.path.join(self.CTNParent.ConfNodePath(), self.CTNType)

   138

   139

    def CTNPath(self,CTNName=None):

   140

        if not CTNName:

   141

            CTNName = self.CTNName()

   142

        return os.path.join(self.CTNParent.CTNPath(),

   143

                            CTNName + NameTypeSeparator + self.CTNType)

   144

   145

    def CTNName(self):

   146

        return self.BaseParams.getName()

   147

   148

    def CTNEnabled(self):

   149

        return self.BaseParams.getEnabled()

   150

   151

    def CTNFullName(self):

   152

        parent = self.CTNParent.CTNFullName()

   153

        if parent != "":

   154

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

   155

        return self.BaseParams.getName()

   156

   157

    def GetIconPath(self, name):

   158

        return opjimg(name)

   159

   160

    def CTNTestModified(self):

   161

        return self.ChangesToSave

   162

   163

    def ProjectTestModified(self):

   164

        """

   165

        recursively check modified status

   166

        """

   167

        if self.CTNTestModified():

   168

            return True

   169

   170

        for CTNChild in self.IterChildren():

   171

            if CTNChild.ProjectTestModified():

   172

                return True

   173

   174

        return False

   175

   176

    def RemoteExec(self, script, **kwargs):

   177

        return self.CTNParent.RemoteExec(script, **kwargs)

   178

   179

    def OnCTNSave(self):

   180

        #Default, do nothing and return success

   181

        return True

   182

   183

    def GetParamsAttributes(self, path = None):

   184

        if path:

   185

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

   186

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

   187

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

   188

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

   189

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

   190

        else:

   191

            params = []

   192

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

   193

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

   194

            if self.CTNParams:

   195

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

   196

            return params

   197

   198

    def SetParamsAttribute(self, path, value):

   199

        self.ChangesToSave = True

   200

        # Filter IEC_Channel and Name, that have specific behavior

   201

        if path == "BaseParams.IEC_Channel":

   202

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

   203

            new_value = self.FindNewIEC_Channel(value)

   204

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

   205

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

   206

            return new_value, True

   207

        elif path == "BaseParams.Name":

   208

            res = self.FindNewName(value)

   209

            self.CTNRequestSave()

   210

            return res, True

   211

   212

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

   213

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

   214

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

   215

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

   216

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

   217

        return value, False

   218

   219

    def CTNMakeDir(self):

   220

        os.mkdir(self.CTNPath())

   221

   222

    def CTNRequestSave(self):

   223

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

   224

            # If confnode do not have corresponding directory

   225

            ctnpath = self.CTNPath()

   226

            if not os.path.isdir(ctnpath):

   227

                # Create it

   228

                os.mkdir(ctnpath)

   229

   230

            # generate XML for base XML parameters controller of the confnode

   231

            if self.MandatoryParams:

   232

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

   233

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

   234

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

   235

                BaseXMLFile.close()

   236

   237

            # generate XML for XML parameters controller of the confnode

   238

            if self.CTNParams:

   239

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

   240

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

   241

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

   242

                XMLFile.close()

   243

   244

            # Call the confnode specific OnCTNSave method

   245

            result = self.OnCTNSave()

   246

            if not result:

   247

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

   248

   249

            # mark confnode as saved

   250

            self.ChangesToSave = False

   251

            # go through all children and do the same

   252

            for CTNChild in self.IterChildren():

   253

                result = CTNChild.CTNRequestSave()

   254

                if result:

   255

                    return result

   256

        return None

   257

   258

    def CTNImport(self, src_CTNPath):

   259

        shutil.copytree(src_CTNPath, self.CTNPath)

   260

        return True

   261

   262

    def CTNGenerate_C(self, buildpath, locations):

   263

        """

   264

        Generate C code

   265

        @param locations: List of complete variables locations \

   266

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

   267

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

   268

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

   269

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

   270

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

   271

            }, ...]

   272

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

   273

        """

   274

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

   275

        return [],"",False

   276

   277

    def _Generate_C(self, buildpath, locations):

   278

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

   279

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

   280

        gen_result = self.CTNGenerate_C(buildpath, locations)

   281

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   282

        extra_files = gen_result[3:]

   283

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

   284

        if CTNCFilesAndCFLAGS:

   285

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

   286

        else:

   287

            LocationCFilesAndCFLAGS = []

   288

   289

        # confnode asks for some LDFLAGS

   290

        if CTNLDFLAGS:

   291

            # LDFLAGS can be either string

   292

            if type(CTNLDFLAGS)==type(str()):

   293

                LDFLAGS=[CTNLDFLAGS]

   294

            #or list of strings

   295

            elif type(CTNLDFLAGS)==type(list()):

   296

                LDFLAGS=CTNLDFLAGS[:]

   297

        else:

   298

            LDFLAGS=[]

   299

   300

        # recurse through all children, and stack their results

   301

        for CTNChild in self.IECSortedChildren():

   302

            new_location = CTNChild.GetCurrentLocation()

   303

            # How deep are we in the tree ?

   304

            depth=len(new_location)

   305

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   306

                CTNChild._Generate_C(

   307

                    #keep the same path

   308

                    buildpath,

   309

                    # filter locations that start with current IEC location

   310

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

   311

            # stack the result

   312

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   313

            LDFLAGS += _LDFLAGS

   314

            extra_files += _extra_files

   315

   316

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   317

   318

    def ConfNodeTypesFactory(self):

   319

        if self.LibraryControler is not None:

   320

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

   321

        return []

   322

   323

    def ParentsTypesFactory(self):

   324

        return self.CTNParent.ParentsTypesFactory() + self.ConfNodeTypesFactory()

   325

   326

    def ConfNodesTypesFactory(self):

   327

        list = self.ConfNodeTypesFactory()

   328

        for CTNChild in self.IterChildren():

   329

            list += CTNChild.ConfNodesTypesFactory()

   330

        return list

   331

   332

    def STLibraryFactory(self):

   333

        if self.LibraryControler is not None:

   334

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

   335

            return program + "\n"

   336

        return ""

   337

   338

    def ConfNodesSTLibraryFactory(self):

   339

        program = self.STLibraryFactory()

   340

        for CTNChild in self.IECSortedChildren():

   341

            program += CTNChild.ConfNodesSTLibraryFactory()

   342

        return program

   343

   344

    def IterChildren(self):

   345

        for CTNType, Children in self.Children.items():

   346

            for CTNInstance in Children:

   347

                yield CTNInstance

   348

   349

    def IECSortedChildren(self):

   350

        # reorder children by IEC_channels

   351

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

   352

        if ordered:

   353

            ordered.sort()

   354

            return zip(*ordered)[1]

   355

        else:

   356

            return []

   357

   358

    def _GetChildBySomething(self, something, toks):

   359

        for CTNInstance in self.IterChildren():

   360

            # if match component of the name

   361

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

   362

                # if Name have other components

   363

                if len(toks) >= 2:

   364

                    # Recurse in order to find the latest object

   365

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

   366

                # No sub name -> found

   367

                return CTNInstance

   368

        # Not found

   369

        return None

   370

   371

    def GetChildByName(self, Name):

   372

        if Name:

   373

            toks = Name.split('.')

   374

            return self._GetChildBySomething("Name", toks)

   375

        else:

   376

            return self

   377

   378

    def GetChildByIECLocation(self, Location):

   379

        if Location:

   380

            return self._GetChildBySomething("IEC_Channel", Location)

   381

        else:

   382

            return self

   383

   384

    def GetCurrentLocation(self):

   385

        """

   386

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

   387

        """

   388

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

   389

   390

    def GetCurrentName(self):

   391

        """

   392

        @return:  String "ParentParentName.ParentName.Name"

   393

        """

   394

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

   395

   396

    def _GetCurrentName(self):

   397

        """

   398

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

   399

        """

   400

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

   401

   402

    def GetCTRoot(self):

   403

        return self.CTNParent.GetCTRoot()

   404

   405

    def GetFullIEC_Channel(self):

   406

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

   407

   408

    def GetLocations(self):

   409

        location = self.GetCurrentLocation()

   410

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

   411

   412

    def GetVariableLocationTree(self):

   413

        '''

   414

        This function is meant to be overridden by confnodes.

   415

   416

        It should returns an list of dictionaries

   417

   418

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

   419

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

   420

        '''

   421

        children = []

   422

        for child in self.IECSortedChildren():

   423

            children.append(child.GetVariableLocationTree())

   424

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

   425

                "type": LOCATION_CONFNODE,

   426

                "location": self.GetFullIEC_Channel(),

   427

                "children": children}

   428

   429

    def FindNewName(self, DesiredName):

   430

        """

   431

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

   432

        @param DesiredName: The desired Name (string)

   433

        """

   434

        # Get Current Name

   435

        CurrentName = self.BaseParams.getName()

   436

        # Do nothing if no change

   437

        #if CurrentName == DesiredName: return CurrentName

   438

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

   439

        AllNames=[]

   440

        for CTNInstance in self.CTNParent.IterChildren():

   441

            if CTNInstance != self:

   442

                AllNames.append(CTNInstance.BaseParams.getName())

   443

   444

        # Find a free name, eventually appending digit

   445

        res = DesiredName

   446

        suffix = 1

   447

        while res in AllNames:

   448

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

   449

            suffix += 1

   450

   451

        # Get old path

   452

        oldname = self.CTNPath()

   453

        # Check previous confnode existance

   454

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

   455

        # Set the new name

   456

        self.BaseParams.setName(res)

   457

        # Rename confnode dir if exist

   458

        if not dontexist:

   459

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

   460

        # warn user he has two left hands

   461

        if DesiredName != res:

   462

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

   463

        return res

   464

   465

    def GetAllChannels(self):

   466

        AllChannels=[]

   467

        for CTNInstance in self.CTNParent.IterChildren():

   468

            if CTNInstance != self:

   469

                AllChannels.append(CTNInstance.BaseParams.getIEC_Channel())

   470

        AllChannels.sort()

   471

        return AllChannels

   472

   473

    def FindNewIEC_Channel(self, DesiredChannel):

   474

        """

   475

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

   476

        @param DesiredChannel: The desired IEC channel (int)

   477

        """

   478

        # Get Current IEC channel

   479

        CurrentChannel = self.BaseParams.getIEC_Channel()

   480

        # Do nothing if no change

   481

        #if CurrentChannel == DesiredChannel: return CurrentChannel