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

    35

import os

    36

import traceback

    37

import types

    38

import shutil

    39

from operator import add

    40

from functools import reduce

    41

    42

from lxml import etree

    43

    44

from xmlclass import GenerateParserFromXSDstring

    45

from PLCControler import LOCATION_CONFNODE

    46

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    47

from POULibrary import UserAddressedException

    48

    49

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

    50

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

    51

          <xsd:element name="BaseParams">

    52

            <xsd:complexType>

    53

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

    54

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

    55

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

    56

            </xsd:complexType>

    57

          </xsd:element>

    58

        </xsd:schema>""")

    59

    60

NameTypeSeparator = '@'

    61

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

    62

    63

    64

class ConfigTreeNode(object):

    65

    """

    66

    This class is the one that define confnodes.

    67

    """

    68

    69

    XSD = None

    70

    CTNChildrenTypes = []

    71

    CTNMaxCount = None

    72

    ConfNodeMethods = []

    73

    LibraryControler = None

    74

    EditorType = ConfTreeNodeEditor

    75

    IconPath = None

    76

    77

    def _AddParamsMembers(self):

    78

        self.CTNParams = None

    79

        if self.XSD:

    80

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    81

            obj = self.Parser.CreateRoot()

    82

            name = obj.getLocalTag()

    83

            self.CTNParams = (name, obj)

    84

            setattr(self, name, obj)

    85

    86

    def __init__(self):

    87

        # Create BaseParam

    88

        self.BaseParams = _BaseParamsParser.CreateRoot()

    89

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

    90

        self._AddParamsMembers()

    91

        self.Children = {}

    92

        self._View = None

    93

        # copy ConfNodeMethods so that it can be later customized

    94

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

    95

    96

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    97

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

    98

    99

    def ConfNodeXmlFilePath(self, CTNName=None):

   100

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

   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 CTNSearch(self, criteria):

   123

        # TODO match config's fields name and fields contents

   124

        return reduce(add, [

   125

            CTNChild.CTNSearch(criteria)

   126

            for CTNChild in self.IterChildren()], [])

   127

   128

    def GetIconName(self):

   129

        return None

   130

   131

    def CTNTestModified(self):

   132

        return self.ChangesToSave

   133

   134

    def CTNMarkModified(self):

   135

        oldChangesToSave = self.ChangesToSave

   136

        self.ChangesToSave = True

   137

        if not oldChangesToSave:

   138

            appframe = self.GetCTRoot().AppFrame

   139

            if appframe is not None:

   140

                appframe.RefreshTitle()

   141

                appframe.RefreshPageTitles()

   142

                appframe.RefreshFileMenu()

   143

   144

    def ProjectTestModified(self):

   145

        """

   146

        recursively check modified status

   147

        """

   148

        if self.CTNTestModified():

   149

            return True

   150

   151

        for CTNChild in self.IterChildren():

   152

            if CTNChild.ProjectTestModified():

   153

                return True

   154

   155

        return False

   156

   157

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

   158

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

   159

   160

    def OnCTNSave(self, from_project_path=None):

   161

        """Default, do nothing and return success"""

   162

        return True

   163

   164

    def GetParamsAttributes(self, path=None):

   165

        if path:

   166

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

   167

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

   168

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

   169

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

   170

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

   171

        else:

   172

            params = []

   173

            if self.CTNParams:

   174

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

   175

            return params

   176

   177

    def SetParamsAttribute(self, path, value):

   178

        self.ChangesToSave = True

   179

        # Filter IEC_Channel and Name, that have specific behavior

   180

        if path == "BaseParams.IEC_Channel":

   181

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

   182

            new_value = self.FindNewIEC_Channel(value)

   183

            if new_value != value:

   184

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

   185

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

   186

            return new_value, True

   187

        elif path == "BaseParams.Name":

   188

            res = self.FindNewName(value)

   189

            self.CTNRequestSave()

   190

            return res, True

   191

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

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

   199

        return value, False

   200

   201

    def CTNMakeDir(self):

   202

        os.mkdir(self.CTNPath())

   203

   204

    def CTNRequestSave(self, from_project_path=None):

   205

        if self.GetCTRoot().CheckProjectPathPerm():

   206

            # If confnode do not have corresponding directory

   207

            ctnpath = self.CTNPath()

   208

            if not os.path.isdir(ctnpath):

   209

                # Create it

   210

                os.mkdir(ctnpath)

   211

   212

            # generate XML for base XML parameters controller of the confnode

   213

            if self.MandatoryParams:

   214

                BaseXMLFile = open(self.ConfNodeBaseXmlFilePath(), 'w', encoding='utf-8')

   215

                BaseXMLFile.write(etree.tostring(

   216

                    self.MandatoryParams[1],

   217

                    pretty_print=True,

   218

                    xml_declaration=True,

   219

                    encoding='utf-8').decode())

   220

                BaseXMLFile.close()

   221

   222

            # generate XML for XML parameters controller of the confnode

   223

            if self.CTNParams:

   224

                XMLFile = open(self.ConfNodeXmlFilePath(), 'w', encoding='utf-8')

   225

                XMLFile.write(etree.tostring(

   226

                    self.CTNParams[1],

   227

                    pretty_print=True,

   228

                    xml_declaration=True,

   229

                    encoding='utf-8').decode())

   230

                XMLFile.close()

   231

   232

            # Call the confnode specific OnCTNSave method

   233

            result = self.OnCTNSave(from_project_path)

   234

            if not result:

   235

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

   236

   237

            # mark confnode as saved

   238

            self.ChangesToSave = False

   239

            # go through all children and do the same

   240

            for CTNChild in self.IterChildren():

   241

                CTNChildPath = None

   242

                if from_project_path is not None:

   243

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   244

                result = CTNChild.CTNRequestSave(CTNChildPath)

   245

                if result:

   246

                    return result

   247

        return None

   248

   249

    def CTNImport(self, src_CTNPath):

   250

        shutil.copytree(src_CTNPath, self.CTNPath)

   251

        return True

   252

   253

    def CTNGlobalInstances(self):

   254

        """

   255

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

   256

        """

   257

        return []

   258

   259

    def _GlobalInstances(self):

   260

        instances = self.CTNGlobalInstances()

   261

        for CTNChild in self.IECSortedChildren():

   262

            instances.extend(CTNChild._GlobalInstances())

   263

        return instances

   264

   265

    def CTNGenerate_C(self, buildpath, locations):

   266

        """

   267

        Generate C code

   268

        @param locations: List of complete variables locations \

   269

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

   270

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

   271

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

   272

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

   273

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

   274

            }, ...]

   275

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

   276

        """

   277

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

   278

        return [], "", False

   279

   280

    def _Generate_C(self, buildpath, locations):

   281

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

   282

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

   283

        gen_result = self.CTNGenerate_C(buildpath, locations)

   284

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   285

        extra_files = gen_result[3:]

   286

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

   287

        if CTNCFilesAndCFLAGS:

   288

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

   289

        else:

   290

            LocationCFilesAndCFLAGS = []

   291

   292

        # confnode asks for some LDFLAGS

   293

        LDFLAGS = []

   294

        if CTNLDFLAGS is not None:

   295

            # LDFLAGS can be either string

   296

            if isinstance(CTNLDFLAGS, str):

   297

                LDFLAGS += [CTNLDFLAGS]

   298

            # or list of strings

   299

            elif isinstance(CTNLDFLAGS, list):

   300

                LDFLAGS += CTNLDFLAGS

   301

   302

        # recurse through all children, and stack their results

   303

        for CTNChild in self.IECSortedChildren():

   304

            new_location = CTNChild.GetCurrentLocation()

   305

            # How deep are we in the tree ?

   306

            depth = len(new_location)

   307

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   308

                CTNChild._Generate_C(

   309

                    # keep the same path

   310

                    buildpath,

   311

                    # filter locations that start with current IEC location

   312

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

   313

            # stack the result

   314

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   315

            LDFLAGS += _LDFLAGS

   316

            extra_files += _extra_files

   317

   318

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   319

   320

    def IterChildren(self):

   321

        for _CTNType, Children in list(self.Children.items()):

   322

            for CTNInstance in Children:

   323

                yield CTNInstance

   324

   325

    def IECSortedChildren(self):

   326

        # reorder children by IEC_channels

   327

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

   328

        if ordered:

   329

            ordered.sort()

   330

            return list(zip(*ordered))[1]

   331

        else:

   332

            return []

   333

   334

    def _GetChildBySomething(self, something, toks):

   335

        for CTNInstance in self.IterChildren():

   336

            # if match component of the name

   337

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

   338

                # if Name have other components

   339

                if len(toks) >= 2:

   340

                    # Recurse in order to find the latest object

   341

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

   342

                # No sub name -> found

   343

                return CTNInstance

   344

        # Not found

   345

        return None

   346

   347

    def GetChildByName(self, Name):

   348

        if Name:

   349

            toks = Name.split('.')

   350

            return self._GetChildBySomething("Name", toks)

   351

        else:

   352

            return self

   353

   354

    def GetChildByIECLocation(self, Location):

   355

        if Location:

   356

            return self._GetChildBySomething("IEC_Channel", Location)

   357

        else:

   358

            return self

   359

   360

    def GetCurrentLocation(self):

   361

        """

   362

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

   363

        """

   364

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

   365

   366

    def GetCurrentName(self):

   367

        """

   368

        @return:  String "ParentParentName.ParentName.Name"

   369

        """

   370

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

   371

   372

    def _GetCurrentName(self):

   373

        """

   374

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

   375

        """

   376

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

   377

   378

    def GetCTRoot(self):

   379

        return self.CTNParent.GetCTRoot()

   380

   381

    def GetFullIEC_Channel(self):

   382

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

   383

   384

    def GetLocations(self):

   385

        location = self.GetCurrentLocation()

   386

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

   387

   388

    def GetVariableLocationTree(self):

   389

        '''

   390

        This function is meant to be overridden by confnodes.

   391

   392

        It should returns an list of dictionaries

   393

   394

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

   395

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

   396

        '''

   397

        children = []

   398

        for child in self.IECSortedChildren():

   399

            children.append(child.GetVariableLocationTree())

   400

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

   401

                "type": LOCATION_CONFNODE,

   402

                "location": self.GetFullIEC_Channel(),

   403

                "children": children}

   404

   405

    def FindNewName(self, DesiredName):

   406

        """

   407

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

   408

        @param DesiredName: The desired Name (string)

   409

        """

   410

   411

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

   412

        AllNames = []

   413

        for CTNInstance in self.CTNParent.IterChildren():

   414

            if CTNInstance != self:

   415

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

   416

   417

        # Find a free name, eventually appending digit

   418

        res = DesiredName

   419

        if DesiredName.endswith("_0"):

   420

            BaseDesiredName = DesiredName[:-2]

   421

        else:

   422

            BaseDesiredName = DesiredName

   423

        suffix = 1

   424

        while res in AllNames:

   425

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

   426

            suffix += 1

   427

   428

        # Check previous confnode existance

   429

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

   430

        if not dontexist:

   431

            # Get old path

   432

            oldpath = self.CTNPath()

   433

        # Set the new name

   434

        self.BaseParams.setName(res)

   435

        # Rename confnode dir if exist

   436

        if not dontexist:

   437

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

   438

        # warn user he has two left hands

   439

        if DesiredName != res:

   440

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

   441

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

   442

        return res

   443

   444

    def GetAllChannels(self):

   445

        AllChannels = []

   446

        for CTNInstance in self.CTNParent.IterChildren():

   447

            if CTNInstance != self:

   448

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

   449

        AllChannels.sort()

   450

        return AllChannels

   451

   452

    def FindNewIEC_Channel(self, DesiredChannel):

   453

        """

   454

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

   455

        @param DesiredChannel: The desired IEC channel (int)

   456

        """

   457

        # Get Current IEC channel

   458

        CurrentChannel = self.BaseParams.getIEC_Channel()

   459

        # Do nothing if no change

   460

        # if CurrentChannel == DesiredChannel: return CurrentChannel

   461

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

   462

        AllChannels = self.GetAllChannels()

   463

   464

        # Now, try to guess the nearest available channel

   465

        res = DesiredChannel

   466

        while res in AllChannels:  # While channel not free

   467

            if res < CurrentChannel:  # Want to go down ?

   468

                res -= 1  # Test for n-1

   469

                if res < 0:

   470

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

   471

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

   472

            else:  # Want to go up ?

   473

                res += 1  # Test for n-1

   474

        # Finally set IEC Channel

   475

        self.BaseParams.setIEC_Channel(res)

   476

        return res

   477

   478

    def GetContextualMenuItems(self):