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

   143

    def ProjectTestModified(self):

   144

        """

   145

        recursively check modified status

   146

        """

   147

        if self.CTNTestModified():

   148

            return True

   149

   150

        for CTNChild in self.IterChildren():

   151

            if CTNChild.ProjectTestModified():

   152

                return True

   153

   154

        return False

   155

   156

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

   157

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

   158

   159

    def OnCTNSave(self, from_project_path=None):

   160

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

   161

        return True

   162

   163

    def GetParamsAttributes(self, path=None):

   164

        if path:

   165

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

   166

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

   167

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

   168

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

   169

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

   170

        else:

   171

            params = []

   172

            if self.CTNParams:

   173

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

   174

            return params

   175

   176

    def SetParamsAttribute(self, path, value):

   177

        self.ChangesToSave = True

   178

        # Filter IEC_Channel and Name, that have specific behavior

   179

        if path == "BaseParams.IEC_Channel":

   180

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

   181

            new_value = self.FindNewIEC_Channel(value)

   182

            if new_value != value:

   183

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

   184

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

   185

            return new_value, True

   186

        elif path == "BaseParams.Name":

   187

            res = self.FindNewName(value)

   188

            self.CTNRequestSave()

   189

            return res, True

   190

   191

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

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

        return value, False

   199

   200

    def CTNMakeDir(self):

   201

        os.mkdir(self.CTNPath())

   202

   203

    def CTNRequestSave(self, from_project_path=None):

   204

        if self.GetCTRoot().CheckProjectPathPerm():

   205

            # If confnode do not have corresponding directory

   206

            ctnpath = self.CTNPath()

   207

            if not os.path.isdir(ctnpath):

   208

                # Create it

   209

                os.mkdir(ctnpath)

   210

   211

            # generate XML for base XML parameters controller of the confnode

   212

            if self.MandatoryParams:

   213

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

   214

                BaseXMLFile.write(etree.tostring(

   215

                    self.MandatoryParams[1],

   216

                    pretty_print=True,

   217

                    xml_declaration=True,

   218

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

   219

                BaseXMLFile.close()

   220

   221

            # generate XML for XML parameters controller of the confnode

   222

            if self.CTNParams:

   223

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

   224

                XMLFile.write(etree.tostring(

   225

                    self.CTNParams[1],

   226

                    pretty_print=True,

   227

                    xml_declaration=True,

   228

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

   229

                XMLFile.close()

   230

   231

            # Call the confnode specific OnCTNSave method

   232

            result = self.OnCTNSave(from_project_path)

   233

            if not result:

   234

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

   235

   236

            # mark confnode as saved

   237

            self.ChangesToSave = False

   238

            # go through all children and do the same

   239

            for CTNChild in self.IterChildren():

   240

                CTNChildPath = None

   241

                if from_project_path is not None:

   242

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   243

                result = CTNChild.CTNRequestSave(CTNChildPath)

   244

                if result:

   245

                    return result

   246

        return None

   247

   248

    def CTNImport(self, src_CTNPath):

   249

        shutil.copytree(src_CTNPath, self.CTNPath)

   250

        return True

   251

   252

    def CTNGlobalInstances(self):

   253

        """

   254

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

   255

        """

   256

        return []

   257

   258

    def _GlobalInstances(self):

   259

        instances = self.CTNGlobalInstances()

   260

        for CTNChild in self.IECSortedChildren():

   261

            instances.extend(CTNChild._GlobalInstances())

   262

        return instances

   263

   264

    def CTNGenerate_C(self, buildpath, locations):

   265

        """

   266

        Generate C code

   267

        @param locations: List of complete variables locations \

   268

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

   269

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

   270

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

   271

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

   272

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

   273

            }, ...]

   274

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

   275

        """

   276

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

   277

        return [], "", False

   278

   279

    def _Generate_C(self, buildpath, locations):

   280

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

   281

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

   282

        gen_result = self.CTNGenerate_C(buildpath, locations)

   283

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   284

        extra_files = gen_result[3:]

   285

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

   286

        if CTNCFilesAndCFLAGS:

   287

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

   288

        else:

   289

            LocationCFilesAndCFLAGS = []

   290

   291

        # confnode asks for some LDFLAGS

   292

        LDFLAGS = []

   293

        if CTNLDFLAGS is not None:

   294

            # LDFLAGS can be either string

   295

            if isinstance(CTNLDFLAGS, str):

   296

                LDFLAGS += [CTNLDFLAGS]

   297

            # or list of strings

   298

            elif isinstance(CTNLDFLAGS, list):

   299

                LDFLAGS += CTNLDFLAGS

   300

   301

        # recurse through all children, and stack their results

   302

        for CTNChild in self.IECSortedChildren():

   303

            new_location = CTNChild.GetCurrentLocation()

   304

            # How deep are we in the tree ?

   305

            depth = len(new_location)

   306

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   307

                CTNChild._Generate_C(

   308

                    # keep the same path

   309

                    buildpath,

   310

                    # filter locations that start with current IEC location

   311

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

   312

            # stack the result

   313

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   314

            LDFLAGS += _LDFLAGS

   315

            extra_files += _extra_files

   316

   317

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   318

   319

    def IterChildren(self):

   320

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

   321

            for CTNInstance in Children:

   322

                yield CTNInstance

   323

   324

    def IECSortedChildren(self):

   325

        # reorder children by IEC_channels

   326

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

   327

        if ordered:

   328

            ordered.sort()

   329

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

   330

        else:

   331

            return []

   332

   333

    def _GetChildBySomething(self, something, toks):

   334

        for CTNInstance in self.IterChildren():

   335

            # if match component of the name

   336

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

   337

                # if Name have other components

   338

                if len(toks) >= 2:

   339

                    # Recurse in order to find the latest object

   340

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

   341

                # No sub name -> found

   342

                return CTNInstance

   343

        # Not found

   344

        return None

   345

   346

    def GetChildByName(self, Name):

   347

        if Name:

   348

            toks = Name.split('.')

   349

            return self._GetChildBySomething("Name", toks)

   350

        else:

   351

            return self

   352

   353

    def GetChildByIECLocation(self, Location):

   354

        if Location:

   355

            return self._GetChildBySomething("IEC_Channel", Location)

   356

        else:

   357

            return self

   358

   359

    def GetCurrentLocation(self):

   360

        """

   361

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

   362

        """

   363

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

   364

   365

    def GetCurrentName(self):

   366

        """

   367

        @return:  String "ParentParentName.ParentName.Name"

   368

        """

   369

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

   370

   371

    def _GetCurrentName(self):

   372

        """

   373

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

   374

        """

   375

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

   376

   377

    def GetCTRoot(self):

   378

        return self.CTNParent.GetCTRoot()

   379

   380

    def GetFullIEC_Channel(self):

   381

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

   382

   383

    def GetLocations(self):

   384

        location = self.GetCurrentLocation()

   385

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

   386

   387

    def GetVariableLocationTree(self):

   388

        '''

   389

        This function is meant to be overridden by confnodes.

   390

   391

        It should returns an list of dictionaries

   392

   393

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

   394

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

   395

        '''

   396

        children = []

   397

        for child in self.IECSortedChildren():

   398

            children.append(child.GetVariableLocationTree())

   399

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

   400

                "type": LOCATION_CONFNODE,

   401

                "location": self.GetFullIEC_Channel(),

   402

                "children": children}

   403

   404

    def FindNewName(self, DesiredName):

   405

        """

   406

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

   407

        @param DesiredName: The desired Name (string)

   408

        """

   409

   410

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

   411

        AllNames = []

   412

        for CTNInstance in self.CTNParent.IterChildren():

   413

            if CTNInstance != self:

   414

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

   415

   416

        # Find a free name, eventually appending digit

   417

        res = DesiredName

   418

        if DesiredName.endswith("_0"):

   419

            BaseDesiredName = DesiredName[:-2]

   420

        else:

   421

            BaseDesiredName = DesiredName

   422

        suffix = 1

   423

        while res in AllNames:

   424

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

   425

            suffix += 1

   426

   427

        # Check previous confnode existance

   428

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

   429

        if not dontexist:

   430

            # Get old path

   431

            oldpath = self.CTNPath()

   432

        # Set the new name

   433

        self.BaseParams.setName(res)

   434

        # Rename confnode dir if exist

   435

        if not dontexist:

   436

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

   437

        # warn user he has two left hands

   438

        if DesiredName != res:

   439

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

   440

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

   441

        return res

   442

   443

    def GetAllChannels(self):

   444

        AllChannels = []

   445

        for CTNInstance in self.CTNParent.IterChildren():

   446

            if CTNInstance != self:

   447

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

   448

        AllChannels.sort()

   449

        return AllChannels

   450

   451

    def FindNewIEC_Channel(self, DesiredChannel):

   452

        """

   453

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

   454

        @param DesiredChannel: The desired IEC channel (int)

   455

        """

   456

        # Get Current IEC channel

   457

        CurrentChannel = self.BaseParams.getIEC_Channel()

   458

        # Do nothing if no change

   459

        # if CurrentChannel == DesiredChannel: return CurrentChannel

   460

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

   461

        AllChannels = self.GetAllChannels()

   462

   463

        # Now, try to guess the nearest available channel

   464

        res = DesiredChannel

   465

        while res in AllChannels:  # While channel not free

   466

            if res < CurrentChannel:  # Want to go down ?

   467

                res -= 1  # Test for n-1

   468

                if res < 0:

   469

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

   470

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

   471

            else:  # Want to go up ?

   472

                res += 1  # Test for n-1

   473

        # Finally set IEC Channel

   474

        self.BaseParams.setIEC_Channel(res)

   475

        return res

   476

   477

    def GetContextualMenuItems(self):

   478

        return None