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

    35

import traceback

    36

import types

    37

import shutil

    38

from lxml import etree

    39

    40

from xmlclass import GenerateParserFromXSDstring

    41

from util.misc import GetClassImporter

    42

    43

from PLCControler import PLCControler, LOCATION_CONFNODE

    44

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    45

    46

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

    47

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

    48

          <xsd:element name="BaseParams">

    49

            <xsd:complexType>

    50

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

    51

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

    52

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

    53

            </xsd:complexType>

    54

          </xsd:element>

    55

        </xsd:schema>""")

    56

    57

NameTypeSeparator = '@'

    58

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

    59

    60

    61

class ConfigTreeNode:

    62

    """

    63

    This class is the one that define confnodes.

    64

    """

    65

    66

    XSD = None

    67

    CTNChildrenTypes = []

    68

    CTNMaxCount = None

    69

    ConfNodeMethods = []

    70

    LibraryControler = None

    71

    EditorType = ConfTreeNodeEditor

    72

    IconPath = None

    73

    74

    def _AddParamsMembers(self):

    75

        self.CTNParams = None

    76

        if self.XSD:

    77

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    78

            obj = self.Parser.CreateRoot()

    79

            name = obj.getLocalTag()

    80

            self.CTNParams = (name, obj)

    81

            setattr(self, name, obj)

    82

    83

    def __init__(self):

    84

        # Create BaseParam

    85

        self.BaseParams = _BaseParamsParser.CreateRoot()

    86

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

    87

        self._AddParamsMembers()

    88

        self.Children = {}

    89

        self._View = None

    90

        # copy ConfNodeMethods so that it can be later customized

    91

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

    92

    93

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    94

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

    95

    96

    def ConfNodeXmlFilePath(self, CTNName=None):

    97

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

    98

    99

    def ConfNodePath(self):

   100

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

   101

   102

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

   103

        if not CTNName:

   104

            CTNName = self.CTNName()

   105

        if not project_path:

   106

            project_path = self.CTNParent.CTNPath()

   107

        return os.path.join(project_path,

   108

                            CTNName + NameTypeSeparator + self.CTNType)

   109

   110

    def CTNName(self):

   111

        return self.BaseParams.getName()

   112

   113

    def CTNEnabled(self):

   114

        return self.BaseParams.getEnabled()

   115

   116

    def CTNFullName(self):

   117

        parent = self.CTNParent.CTNFullName()

   118

        if parent != "":

   119

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

   120

        return self.BaseParams.getName()

   121

   122

    def GetIconName(self):

   123

        return None

   124

   125

    def CTNTestModified(self):

   126

        return self.ChangesToSave

   127

   128

    def ProjectTestModified(self):

   129

        """

   130

        recursively check modified status

   131

        """

   132

        if self.CTNTestModified():

   133

            return True

   134

   135

        for CTNChild in self.IterChildren():

   136

            if CTNChild.ProjectTestModified():

   137

                return True

   138

   139

        return False

   140

   141

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

   142

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

   143

   144

    def OnCTNSave(self, from_project_path=None):

   145

        #Default, do nothing and return success

   146

        return True

   147

   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.CTNParams and parts[0] == self.CTNParams[0]:

   154

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

   155

        else:

   156

            params = []

   157

            if self.CTNParams:

   158

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

   159

            return params

   160

   161

    def SetParamsAttribute(self, path, value):

   162

        self.ChangesToSave = True

   163

        # Filter IEC_Channel and Name, that have specific behavior

   164

        if path == "BaseParams.IEC_Channel":

   165

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

   166

            new_value = self.FindNewIEC_Channel(value)

   167

            if new_value != value:

   168

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

   169

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

   170

            return new_value, True

   171

        elif path == "BaseParams.Name":

   172

            res = self.FindNewName(value)

   173

            self.CTNRequestSave()

   174

            return res, True

   175

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

        return value, False

   184

   185

    def CTNMakeDir(self):

   186

        os.mkdir(self.CTNPath())

   187

   188

    def CTNRequestSave(self, from_project_path=None):

   189

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

   190

            # If confnode do not have corresponding directory

   191

            ctnpath = self.CTNPath()

   192

            if not os.path.isdir(ctnpath):

   193

                # Create it

   194

                os.mkdir(ctnpath)

   195

   196

            # generate XML for base XML parameters controller of the confnode

   197

            if self.MandatoryParams:

   198

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

   199

                BaseXMLFile.write(etree.tostring(

   200

                    self.MandatoryParams[1],

   201

                    pretty_print=True,

   202

                    xml_declaration=True,

   203

                    encoding='utf-8'))

   204

                BaseXMLFile.close()

   205

   206

            # generate XML for XML parameters controller of the confnode

   207

            if self.CTNParams:

   208

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

   209

                XMLFile.write(etree.tostring(

   210

                    self.CTNParams[1],

   211

                    pretty_print=True,

   212

                    xml_declaration=True,

   213

                    encoding='utf-8'))

   214

                XMLFile.close()

   215

   216

            # Call the confnode specific OnCTNSave method

   217

            result = self.OnCTNSave(from_project_path)

   218

            if not result:

   219

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

   220

   221

            # mark confnode as saved

   222

            self.ChangesToSave = False

   223

            # go through all children and do the same

   224

            for CTNChild in self.IterChildren():

   225

                CTNChildPath = None

   226

                if from_project_path is not None:

   227

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   228

                result = CTNChild.CTNRequestSave(CTNChildPath)

   229

                if result:

   230

                    return result

   231

        return None

   232

   233

    def CTNImport(self, src_CTNPath):

   234

        shutil.copytree(src_CTNPath, self.CTNPath)

   235

        return True

   236

   237

    def CTNGlobalInstances(self):

   238

        """

   239

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

   240

        """

   241

        return []

   242

   243

    def _GlobalInstances(self):

   244

        instances = self.CTNGlobalInstances()

   245

        for CTNChild in self.IECSortedChildren():

   246

            instances.extend(CTNChild._GlobalInstances())

   247

        return instances

   248

   249

    def CTNGenerate_C(self, buildpath, locations):

   250

        """

   251

        Generate C code

   252

        @param locations: List of complete variables locations \

   253

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

   254

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

   255

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

   256

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

   257

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

   258

            }, ...]

   259

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

   260

        """

   261

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

   262

        return [], "", False

   263

   264

    def _Generate_C(self, buildpath, locations):

   265

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

   266

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

   267

        gen_result = self.CTNGenerate_C(buildpath, locations)

   268

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   269

        extra_files = gen_result[3:]

   270

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

   271

        if CTNCFilesAndCFLAGS:

   272

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

   273

        else:

   274

            LocationCFilesAndCFLAGS = []

   275

   276

        # confnode asks for some LDFLAGS

   277

        if CTNLDFLAGS:

   278

            # LDFLAGS can be either string

   279

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

   280

                LDFLAGS = [CTNLDFLAGS]

   281

            # or list of strings

   282

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

   283

                LDFLAGS = CTNLDFLAGS[:]

   284

        else:

   285

            LDFLAGS = []

   286

   287

        # recurse through all children, and stack their results

   288

        for CTNChild in self.IECSortedChildren():

   289

            new_location = CTNChild.GetCurrentLocation()

   290

            # How deep are we in the tree ?

   291

            depth = len(new_location)

   292

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   293

                CTNChild._Generate_C(

   294

                    # keep the same path

   295

                    buildpath,

   296

                    # filter locations that start with current IEC location

   297

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

   298

            # stack the result

   299

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   300

            LDFLAGS += _LDFLAGS

   301

            extra_files += _extra_files

   302

   303

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   304

   305

    def IterChildren(self):

   306

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

   307

            for CTNInstance in Children:

   308

                yield CTNInstance

   309

   310

    def IECSortedChildren(self):

   311

        # reorder children by IEC_channels

   312

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

   313

        if ordered:

   314

            ordered.sort()

   315

            return zip(*ordered)[1]

   316

        else:

   317

            return []

   318

   319

    def _GetChildBySomething(self, something, toks):

   320

        for CTNInstance in self.IterChildren():

   321

            # if match component of the name

   322

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

   323

                # if Name have other components

   324

                if len(toks) >= 2:

   325

                    # Recurse in order to find the latest object

   326

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

   327

                # No sub name -> found

   328

                return CTNInstance

   329

        # Not found

   330

        return None

   331

   332

    def GetChildByName(self, Name):

   333

        if Name:

   334

            toks = Name.split('.')

   335

            return self._GetChildBySomething("Name", toks)

   336

        else:

   337

            return self

   338

   339

    def GetChildByIECLocation(self, Location):

   340

        if Location:

   341

            return self._GetChildBySomething("IEC_Channel", Location)

   342

        else:

   343

            return self

   344

   345

    def GetCurrentLocation(self):

   346

        """

   347

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

   348

        """

   349

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

   350

   351

    def GetCurrentName(self):

   352

        """

   353

        @return:  String "ParentParentName.ParentName.Name"

   354

        """

   355

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

   356

   357

    def _GetCurrentName(self):

   358

        """

   359

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

   360

        """

   361

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

   362

   363

    def GetCTRoot(self):

   364

        return self.CTNParent.GetCTRoot()

   365

   366

    def GetFullIEC_Channel(self):

   367

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

   368

   369

    def GetLocations(self):

   370

        location = self.GetCurrentLocation()

   371

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

   372

   373

    def GetVariableLocationTree(self):

   374

        '''

   375

        This function is meant to be overridden by confnodes.

   376

   377

        It should returns an list of dictionaries

   378

   379

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

   380

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

   381

        '''

   382

        children = []

   383

        for child in self.IECSortedChildren():

   384

            children.append(child.GetVariableLocationTree())

   385

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

   386

                "type": LOCATION_CONFNODE,

   387

                "location": self.GetFullIEC_Channel(),

   388

                "children": children}

   389

   390

    def FindNewName(self, DesiredName):

   391

        """

   392

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

   393

        @param DesiredName: The desired Name (string)

   394

        """

   395

        # Get Current Name

   396

        CurrentName = self.BaseParams.getName()

   397

        # Do nothing if no change

   398

        #if CurrentName == DesiredName: return CurrentName

   399

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

   400

        AllNames = []

   401

        for CTNInstance in self.CTNParent.IterChildren():

   402

            if CTNInstance != self:

   403

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

   404

   405

        # Find a free name, eventually appending digit

   406

        res = DesiredName

   407

        if DesiredName.endswith("_0"):

   408

            BaseDesiredName = DesiredName[:-2]

   409

        else:

   410

            BaseDesiredName = DesiredName

   411

        suffix = 1

   412

        while res in AllNames:

   413

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

   414

            suffix += 1

   415

   416

        # Get old path

   417

        oldname = self.CTNPath()

   418

        # Check previous confnode existance

   419

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

   420

        # Set the new name

   421

        self.BaseParams.setName(res)

   422

        # Rename confnode dir if exist

   423

        if not dontexist:

   424

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

   425

        # warn user he has two left hands

   426

        if DesiredName != res:

   428

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

   429

        return res

   430

   431

    def GetAllChannels(self):

   432

        AllChannels = []

   433

        for CTNInstance in self.CTNParent.IterChildren():

   434

            if CTNInstance != self:

   435

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

   436

        AllChannels.sort()

   437

        return AllChannels

   438

   439

    def FindNewIEC_Channel(self, DesiredChannel):

   440

        """

   441

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

   442

        @param DesiredChannel: The desired IEC channel (int)

   443

        """

   444

        # Get Current IEC channel

   445

        CurrentChannel = self.BaseParams.getIEC_Channel()

   446

        # Do nothing if no change

   447

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   448

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

   449

        AllChannels = self.GetAllChannels()

   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.GetCTRoot().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

        return res

   464

   465

    def GetContextualMenuItems(self):

   466

        return None

   467

   468

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

   469

        if self.EditorType is not None:

   470

            app_frame = self.GetCTRoot().AppFrame

   471

            if self._View is None and not onlyopened:

   472

   473

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

   474

   475

            if self._View is not None:

   476

                if name is None:

   477

                    name = self.CTNFullName()

   478

                app_frame.EditProjectElement(self._View, name)

   479