1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

"""

    26

Config Tree Node base class.

    27

    28

- A Beremiz project is organized in a tree each node derivate from ConfigTreeNode

    29

- Project tree organization match filesystem organization of project directory.

    30

- Each node of the tree have its own xml configuration, whose grammar is defined for each node type, as XSD

    31

- ... TODO : document

    32

"""

    33

    34

import os,traceback,types

    35

import shutil

    36

from lxml import etree

    37

    38

from xmlclass import GenerateParserFromXSDstring

    39

from util.misc import GetClassImporter

    40

    41

from PLCControler import PLCControler, LOCATION_CONFNODE

    42

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    43

    44

_BaseParamsParser = GenerateParserFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>

    45

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

    46

          <xsd:element name="BaseParams">

    47

            <xsd:complexType>

    48

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

    49

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

    50

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

    51

            </xsd:complexType>

    52

          </xsd:element>

    53

        </xsd:schema>""")

    54

    55

NameTypeSeparator = '@'

    56

XSDSchemaErrorMessage = _("{a1} XML file doesn't follow XSD schema at line %{a2}:\n{a3}")

    57

    58

class ConfigTreeNode:

    59

    """

    60

    This class is the one that define confnodes.

    61

    """

    62

    63

    XSD = None

    64

    CTNChildrenTypes = []

    65

    CTNMaxCount = None

    66

    ConfNodeMethods = []

    67

    LibraryControler = None

    68

    EditorType = ConfTreeNodeEditor

    69

    IconPath = None

    70

    71

    def _AddParamsMembers(self):

    72

        self.CTNParams = None

    73

        if self.XSD:

    74

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    75

            obj = self.Parser.CreateRoot()

    76

            name = obj.getLocalTag()

    77

            self.CTNParams = (name, obj)

    78

            setattr(self, name, obj)

    79

    80

    def __init__(self):

    81

        # Create BaseParam 

    82

        self.BaseParams = _BaseParamsParser.CreateRoot()

    83

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

    84

        self._AddParamsMembers()

    85

        self.Children = {}

    86

        self._View = None

    87

        # copy ConfNodeMethods so that it can be later customized

    88

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

    89

    90

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    91

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

    92

    93

    def ConfNodeXmlFilePath(self, CTNName=None):

    94

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

    95

    96

    def ConfNodePath(self):

    97

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

    98

    99

    def CTNPath(self,CTNName=None,project_path=None):

   100

        if not CTNName:

   101

            CTNName = self.CTNName()

   102

        if not project_path:

   103

            project_path = self.CTNParent.CTNPath()

   104

        return os.path.join(project_path,

   105

                            CTNName + NameTypeSeparator + self.CTNType)

   106

   107

    def CTNName(self):

   108

        return self.BaseParams.getName()

   109

   110

    def CTNEnabled(self):

   111

        return self.BaseParams.getEnabled()

   112

   113

    def CTNFullName(self):

   114

        parent = self.CTNParent.CTNFullName()

   115

        if parent != "":

   116

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

   117

        return self.BaseParams.getName()

   118

   119

    def GetIconName(self):

   120

        return None

   121

   122

    def CTNTestModified(self):

   123

        return self.ChangesToSave

   124

   125

    def ProjectTestModified(self):

   126

        """

   127

        recursively check modified status

   128

        """

   129

        if self.CTNTestModified():

   130

            return True

   131

   132

        for CTNChild in self.IterChildren():

   133

            if CTNChild.ProjectTestModified():

   134

                return True

   135

   136

        return False

   137

   138

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

   139

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

   140

   141

    def OnCTNSave(self, from_project_path=None):

   142

        #Default, do nothing and return success

   143

        return True

   144

   145

    def GetParamsAttributes(self, path = None):

   146

        if path:

   147

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

   148

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

   149

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

   150

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

   151

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

   152

        else:

   153

            params = []

   154

            if self.CTNParams:

   155

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

   156

            return params

   157

   158

    def SetParamsAttribute(self, path, value):

   159

        self.ChangesToSave = True

   160

        # Filter IEC_Channel and Name, that have specific behavior

   161

        if path == "BaseParams.IEC_Channel":

   162

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

   163

            new_value = self.FindNewIEC_Channel(value)

   164

            if new_value != value:

   165

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

   166

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

   167

            return new_value, True

   168

        elif path == "BaseParams.Name":

   169

            res = self.FindNewName(value)

   170

            self.CTNRequestSave()

   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

            value = self.MandatoryParams[1].getElementInfos(parts[0], parts[1])["value"]

   177

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

   178

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

   179

            value = self.CTNParams[1].getElementInfos(parts[0], parts[1])["value"]

   180

        return value, False

   181

   182

    def CTNMakeDir(self):

   183

        os.mkdir(self.CTNPath())

   184

   185

    def CTNRequestSave(self, from_project_path=None):

   186

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

   187

            # If confnode do not have corresponding directory

   188

            ctnpath = self.CTNPath()

   189

            if not os.path.isdir(ctnpath):

   190

                # Create it

   191

                os.mkdir(ctnpath)

   192

   193

            # generate XML for base XML parameters controller of the confnode

   194

            if self.MandatoryParams:

   195

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

   196

                BaseXMLFile.write(etree.tostring(

   197

                    self.MandatoryParams[1], 

   198

                    pretty_print=True, 

   199

                    xml_declaration=True, 

   200

                    encoding='utf-8'))

   201

                BaseXMLFile.close()

   202

   203

            # generate XML for XML parameters controller of the confnode

   204

            if self.CTNParams:

   205

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

   206

                XMLFile.write(etree.tostring(

   207

                    self.CTNParams[1], 

   208

                    pretty_print=True, 

   209

                    xml_declaration=True, 

   210

                    encoding='utf-8'))

   211

                XMLFile.close()

   212

   213

            # Call the confnode specific OnCTNSave method

   214

            result = self.OnCTNSave(from_project_path)

   215

            if not result:

   216

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

   217

   218

            # mark confnode as saved

   219

            self.ChangesToSave = False

   220

            # go through all children and do the same

   221

            for CTNChild in self.IterChildren():

   222

                CTNChildPath = None

   223

                if from_project_path is not None:

   224

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   225

                result = CTNChild.CTNRequestSave(CTNChildPath)

   226

                if result:

   227

                    return result

   228

        return None

   229

   230

    def CTNImport(self, src_CTNPath):

   231

        shutil.copytree(src_CTNPath, self.CTNPath)

   232

        return True

   233

   234

    def CTNGlobalInstances(self):

   235

        """

   236

        @return: [(instance_name, instance_type),...]

   237

        """

   238

        return []

   239

   240

    def _GlobalInstances(self):

   241

        instances = self.CTNGlobalInstances()

   242

        for CTNChild in self.IECSortedChildren():

   243

            instances.extend(CTNChild._GlobalInstances())

   244

        return instances

   245

   246

    def CTNGenerate_C(self, buildpath, locations):

   247

        """

   248

        Generate C code

   249

        @param locations: List of complete variables locations \

   250

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

   251

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

   252

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

   253

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

   254

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

   255

            }, ...]

   256

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

   257

        """

   258

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

   259

        return [],"",False

   260

   261

    def _Generate_C(self, buildpath, locations):

   262

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

   263

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

   264

        gen_result = self.CTNGenerate_C(buildpath, locations)

   265

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   266

        extra_files = gen_result[3:]

   267

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

   268

        if CTNCFilesAndCFLAGS:

   269

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

   270

        else:

   271

            LocationCFilesAndCFLAGS = []

   272

   273

        # confnode asks for some LDFLAGS

   274

        if CTNLDFLAGS:

   275

            # LDFLAGS can be either string

   276

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

   277

                LDFLAGS=[CTNLDFLAGS]

   278

            #or list of strings

   279

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

   280

                LDFLAGS=CTNLDFLAGS[:]

   281

        else:

   282

            LDFLAGS=[]

   283

   284

        # recurse through all children, and stack their results

   285

        for CTNChild in self.IECSortedChildren():

   286

            new_location = CTNChild.GetCurrentLocation()

   287

            # How deep are we in the tree ?

   288

            depth=len(new_location)

   289

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   290

                CTNChild._Generate_C(

   291

                    #keep the same path

   292

                    buildpath,

   293

                    # filter locations that start with current IEC location

   294

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

   295

            # stack the result

   296

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   297

            LDFLAGS += _LDFLAGS

   298

            extra_files += _extra_files

   299

   300

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   301

   302

    def IterChildren(self):

   303

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

   304

            for CTNInstance in Children:

   305

                yield CTNInstance

   306

   307

    def IECSortedChildren(self):

   308

        # reorder children by IEC_channels

   309

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

   310

        if ordered:

   311

            ordered.sort()

   312

            return zip(*ordered)[1]

   313

        else:

   314

            return []

   315

   316

    def _GetChildBySomething(self, something, toks):

   317

        for CTNInstance in self.IterChildren():

   318

            # if match component of the name

   319

            if getattr(CTNInstance.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 CTNInstance._GetChildBySomething( something, toks[1:])

   324

                # No sub name -> found

   325

                return CTNInstance

   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 confnode IEC location of current confnode : %I0.0.4.5 => (0,0,4,5)

   345

        """

   346

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

   347

   348

    def GetCurrentName(self):

   349

        """

   350

        @return:  String "ParentParentName.ParentName.Name"

   351

        """

   352

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

   353

   354

    def _GetCurrentName(self):

   355

        """

   356

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

   357

        """

   358

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

   359

   360

    def GetCTRoot(self):

   361

        return self.CTNParent.GetCTRoot()

   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.CTNParent.GetLocations() if loc["LOC"][0:len(location)] == location]

   369

   370

    def GetVariableLocationTree(self):

   371

        '''

   372

        This function is meant to be overridden by confnodes.

   373

   374

        It should returns an list of dictionaries

   375

   376

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

   377

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

   378

        '''

   379

        children = []

   380

        for child in self.IECSortedChildren():

   381

            children.append(child.GetVariableLocationTree())

   382

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

   383

                "type": LOCATION_CONFNODE,

   384

                "location": self.GetFullIEC_Channel(),

   385

                "children": children}

   386

   387

    def FindNewName(self, DesiredName):

   388

        """

   389

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

   390

        @param DesiredName: The desired Name (string)

   391

        """

   392

        # Get Current Name

   393

        CurrentName = self.BaseParams.getName()

   394

        # Do nothing if no change

   395

        #if CurrentName == DesiredName: return CurrentName

   396

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

   397

        AllNames=[]

   398

        for CTNInstance in self.CTNParent.IterChildren():

   399

            if CTNInstance != self:

   400

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

   401

   402

        # Find a free name, eventually appending digit

   403

        res = DesiredName

   404

        if DesiredName.endswith("_0"):

   405

            BaseDesiredName = DesiredName[:-2]

   406

        else:

   407

            BaseDesiredName = DesiredName

   408

        suffix = 1

   409

        while res in AllNames:

   410

            res = "%s_%d"%(BaseDesiredName, suffix)

   411

            suffix += 1

   412

   413

        # Get old path

   414

        oldname = self.CTNPath()

   415

        # Check previous confnode existance

   416

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

   417

        # Set the new name

   418

        self.BaseParams.setName(res)

   419

        # Rename confnode dir if exist

   420

        if not dontexist:

   421

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

   422

        # warn user he has two left hands

   423

        if DesiredName != res:

   424

            msg = _("A child named \"{a1}\" already exists -> \"{a2}\"\n").format(a1 = DesiredName, a2 = res)

   425

            self.GetCTRoot().logger.write_warning(msg)

   426

        return res

   427

   428

    def GetAllChannels(self):

   429

        AllChannels=[]

   430

        for CTNInstance in self.CTNParent.IterChildren():

   431

            if CTNInstance != self:

   432

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

   433

        AllChannels.sort()

   434

        return AllChannels

   435

   436

    def FindNewIEC_Channel(self, DesiredChannel):

   437

        """

   438

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

   439

        @param DesiredChannel: The desired IEC channel (int)

   440

        """

   441

        # Get Current IEC channel

   442

        CurrentChannel = self.BaseParams.getIEC_Channel()

   443

        # Do nothing if no change

   444

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   445

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

   446

        AllChannels = self.GetAllChannels()

   447

   448

        # Now, try to guess the nearest available channel

   449

        res = DesiredChannel

   450

        while res in AllChannels: # While channel not free

   451

            if res < CurrentChannel: # Want to go down ?

   452

                res -=  1 # Test for n-1

   453

                if res < 0 :

   454

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

   455

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

   456

            else : # Want to go up ?

   457

                res +=  1 # Test for n-1

   458

        # Finally set IEC Channel

   459

        self.BaseParams.setIEC_Channel(res)

   460

        return res

   461

   462

    def GetContextualMenuItems(self):

   463

        return None

   464

   465

    def _OpenView(self, name=None, onlyopened=False):

   466

        if self.EditorType is not None:

   467

            app_frame = self.GetCTRoot().AppFrame

   468

            if self._View is None and not onlyopened:

   469

   470

                self._View = self.EditorType(app_frame.TabsOpened, self, app_frame)

   471

   472

            if self._View is not None:

   473

                if name is None:

   474

                    name = self.CTNFullName()

   475

                app_frame.EditProjectElement(self._View, name)

   476

   477

            return self._View

   478

        return None

   479

   480

    def _CloseView(self, view):

   481

        app_frame = self.GetCTRoot().AppFrame