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

from __future__ import absolute_import

    35

import os

    36

import traceback

    37

import types

    38

import shutil

    39

from operator import add

    40

from functools import reduce

    41

from builtins import str as text

    42

from past.builtins import execfile

    43

    44

from lxml import etree

    45

    46

from xmlclass import GenerateParserFromXSDstring

    47

from PLCControler import LOCATION_CONFNODE

    48

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    49

from POULibrary import UserAddressedException

    50

    51

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

    52

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

    53

          <xsd:element name="BaseParams">

    54

            <xsd:complexType>

    55

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

    56

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

    57

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

    58

            </xsd:complexType>

    59

          </xsd:element>

    60

        </xsd:schema>""")

    61

    62

NameTypeSeparator = '@'

    63

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

    64

    65

    66

class ConfigTreeNode(object):

    67

    """

    68

    This class is the one that define confnodes.

    69

    """

    70

    71

    XSD = None

    72

    CTNChildrenTypes = []

    73

    CTNMaxCount = None

    74

    ConfNodeMethods = []

    75

    LibraryControler = None

    76

    EditorType = ConfTreeNodeEditor

    77

    IconPath = None

    78

    79

    def _AddParamsMembers(self):

    80

        self.CTNParams = None

    81

        if self.XSD:

    82

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    83

            obj = self.Parser.CreateRoot()

    84

            name = obj.getLocalTag()

    85

            self.CTNParams = (name, obj)

    86

            setattr(self, name, obj)

    87

    88

    def __init__(self):

    89

        # Create BaseParam

    90

        self.BaseParams = _BaseParamsParser.CreateRoot()

    91

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

    92

        self._AddParamsMembers()

    93

        self.Children = {}

    94

        self._View = None

    95

        # copy ConfNodeMethods so that it can be later customized

    96

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

    97

    98

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    99

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

   100

   101

    def ConfNodeXmlFilePath(self, CTNName=None):

   102

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

   103

   104

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

   105

        if not CTNName:

   106

            CTNName = self.CTNName()

   107

        if not project_path:

   108

            project_path = self.CTNParent.CTNPath()

   109

        return os.path.join(project_path,

   110

                            CTNName + NameTypeSeparator + self.CTNType)

   111

   112

    def CTNName(self):

   113

        return self.BaseParams.getName()

   114

   115

    def CTNEnabled(self):

   116

        return self.BaseParams.getEnabled()

   117

   118

    def CTNFullName(self):

   119

        parent = self.CTNParent.CTNFullName()

   120

        if parent != "":

   121

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

   122

        return self.BaseParams.getName()

   123

   124

    def CTNSearch(self, criteria):

   125

        # TODO match config's fields name and fields contents

   126

        return reduce(add, [

   127

            CTNChild.CTNSearch(criteria)

   128

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

   129

   130

    def GetIconName(self):

   131

        return None

   132

   133

    def CTNTestModified(self):

   134

        return self.ChangesToSave

   135

   136

    def ProjectTestModified(self):

   137

        """

   138

        recursively check modified status

   139

        """

   140

        if self.CTNTestModified():

   141

            return True

   142

   143

        for CTNChild in self.IterChildren():

   144

            if CTNChild.ProjectTestModified():

   145

                return True

   146

   147

        return False

   148

   149

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

   150

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

   151

   152

    def OnCTNSave(self, from_project_path=None):

   153

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

   154

        return True

   155

   156

    def GetParamsAttributes(self, path=None):

   157

        if path:

   158

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

   159

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

   160

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

   161

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

   162

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

   163

        else:

   164

            params = []

   165

            if self.CTNParams:

   166

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

   167

            return params

   168

   169

    def SetParamsAttribute(self, path, value):

   170

        self.ChangesToSave = True

   171

        # Filter IEC_Channel and Name, that have specific behavior

   172

        if path == "BaseParams.IEC_Channel":

   173

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

   174

            new_value = self.FindNewIEC_Channel(value)

   175

            if new_value != value:

   176

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

   177

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

   178

            return new_value, True

   179

        elif path == "BaseParams.Name":

   180

            res = self.FindNewName(value)

   181

            self.CTNRequestSave()

   182

            return res, True

   183

   184

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

   185

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

   186

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

   187

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

   188

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

   189

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

   190

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

   191

        return value, False

   192

   193

    def CTNMakeDir(self):

   194

        os.mkdir(self.CTNPath())

   195

   196

    def CTNRequestSave(self, from_project_path=None):

   197

        if self.GetCTRoot().CheckProjectPathPerm():

   198

            # If confnode do not have corresponding directory

   199

            ctnpath = self.CTNPath()

   200

            if not os.path.isdir(ctnpath):

   201

                # Create it

   202

                os.mkdir(ctnpath)

   203

   204

            # generate XML for base XML parameters controller of the confnode

   205

            if self.MandatoryParams:

   206

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

   207

                BaseXMLFile.write(etree.tostring(

   208

                    self.MandatoryParams[1],

   209

                    pretty_print=True,

   210

                    xml_declaration=True,

   211

                    encoding='utf-8'))

   212

                BaseXMLFile.close()

   213

   214

            # generate XML for XML parameters controller of the confnode

   215

            if self.CTNParams:

   216

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

   217

                XMLFile.write(etree.tostring(

   218

                    self.CTNParams[1],

   219

                    pretty_print=True,

   220

                    xml_declaration=True,

   221

                    encoding='utf-8'))

   222

                XMLFile.close()

   223

   224

            # Call the confnode specific OnCTNSave method

   225

            result = self.OnCTNSave(from_project_path)

   226

            if not result:

   227

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

   228

   229

            # mark confnode as saved

   230

            self.ChangesToSave = False

   231

            # go through all children and do the same

   232

            for CTNChild in self.IterChildren():

   233

                CTNChildPath = None

   234

                if from_project_path is not None:

   235

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   236

                result = CTNChild.CTNRequestSave(CTNChildPath)

   237

                if result:

   238

                    return result

   239

        return None

   240

   241

    def CTNImport(self, src_CTNPath):

   242

        shutil.copytree(src_CTNPath, self.CTNPath)

   243

        return True

   244

   245

    def CTNGlobalInstances(self):

   246

        """

   247

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

   248

        """

   249

        return []

   250

   251

    def _GlobalInstances(self):

   252

        instances = self.CTNGlobalInstances()

   253

        for CTNChild in self.IECSortedChildren():

   254

            instances.extend(CTNChild._GlobalInstances())

   255

        return instances

   256

   257

    def CTNGenerate_C(self, buildpath, locations):

   258

        """

   259

        Generate C code

   260

        @param locations: List of complete variables locations \

   261

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

   262

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

   263

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

   264

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

   265

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

   266

            }, ...]

   267

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

   268

        """

   269

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

   270

        return [], "", False

   271

   272

    def _Generate_C(self, buildpath, locations):

   273

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

   274

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

   275

        gen_result = self.CTNGenerate_C(buildpath, locations)

   276

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   277

        extra_files = gen_result[3:]

   278

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

   279

        if CTNCFilesAndCFLAGS:

   280

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

   281

        else:

   282

            LocationCFilesAndCFLAGS = []

   283

   284

        # confnode asks for some LDFLAGS

   285

        LDFLAGS = []

   286

        if CTNLDFLAGS is not None:

   287

            # LDFLAGS can be either string

   288

            if isinstance(CTNLDFLAGS, (str, text)):

   289

                LDFLAGS += [CTNLDFLAGS]

   290

            # or list of strings

   291

            elif isinstance(CTNLDFLAGS, list):

   292

                LDFLAGS += CTNLDFLAGS

   293

   294

        # recurse through all children, and stack their results

   295

        for CTNChild in self.IECSortedChildren():

   296

            new_location = CTNChild.GetCurrentLocation()

   297

            # How deep are we in the tree ?

   298

            depth = len(new_location)

   299

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   300

                CTNChild._Generate_C(

   301

                    # keep the same path

   302

                    buildpath,

   303

                    # filter locations that start with current IEC location

   304

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

   305

            # stack the result

   306

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   307

            LDFLAGS += _LDFLAGS

   308

            extra_files += _extra_files

   309

   310

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   311

   312

    def IterChildren(self):

   313

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

   314

            for CTNInstance in Children:

   315

                yield CTNInstance

   316

   317

    def IECSortedChildren(self):

   318

        # reorder children by IEC_channels

   319

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

   320

        if ordered:

   321

            ordered.sort()

   322

            return zip(*ordered)[1]

   323

        else:

   324

            return []

   325

   326

    def _GetChildBySomething(self, something, toks):

   327

        for CTNInstance in self.IterChildren():

   328

            # if match component of the name

   329

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

   330

                # if Name have other components

   331

                if len(toks) >= 2:

   332

                    # Recurse in order to find the latest object

   333

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

   334

                # No sub name -> found

   335

                return CTNInstance

   336

        # Not found

   337

        return None

   338

   339

    def GetChildByName(self, Name):

   340

        if Name:

   341

            toks = Name.split('.')

   342

            return self._GetChildBySomething("Name", toks)

   343

        else:

   344

            return self

   345

   346

    def GetChildByIECLocation(self, Location):

   347

        if Location:

   348

            return self._GetChildBySomething("IEC_Channel", Location)

   349

        else:

   350

            return self

   351

   352

    def GetCurrentLocation(self):

   353

        """

   354

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

   355

        """

   356

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

   357

   358

    def GetCurrentName(self):

   359

        """

   360

        @return:  String "ParentParentName.ParentName.Name"

   361

        """

   362

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

   363

   364

    def _GetCurrentName(self):

   365

        """

   366

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

   367

        """

   368

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

   369

   370

    def GetCTRoot(self):

   371

        return self.CTNParent.GetCTRoot()

   372

   373

    def GetFullIEC_Channel(self):

   374

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

   375

   376

    def GetLocations(self):

   377

        location = self.GetCurrentLocation()

   378

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

   379

   380

    def GetVariableLocationTree(self):

   381

        '''

   382

        This function is meant to be overridden by confnodes.

   383

   384

        It should returns an list of dictionaries

   385

   386

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

   387

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

   388

        '''

   389

        children = []

   390

        for child in self.IECSortedChildren():

   391

            children.append(child.GetVariableLocationTree())

   392

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

   393

                "type": LOCATION_CONFNODE,

   394

                "location": self.GetFullIEC_Channel(),

   395

                "children": children}

   396

   397

    def FindNewName(self, DesiredName):

   398

        """

   399

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

   400

        @param DesiredName: The desired Name (string)

   401

        """

   402

   403

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

   404

        AllNames = []

   405

        for CTNInstance in self.CTNParent.IterChildren():

   406

            if CTNInstance != self:

   407

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

   408

   409

        # Find a free name, eventually appending digit

   410

        res = DesiredName

   411

        if DesiredName.endswith("_0"):

   412

            BaseDesiredName = DesiredName[:-2]

   413

        else:

   414

            BaseDesiredName = DesiredName

   415

        suffix = 1

   416

        while res in AllNames:

   417

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

   418

            suffix += 1

   419

   420

        # Check previous confnode existance

   421

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

   422

        if not dontexist:

   423

            # Get old path

   424

            oldpath = self.CTNPath()

   425

        # Set the new name

   426

        self.BaseParams.setName(res)

   427

        # Rename confnode dir if exist

   428

        if not dontexist:

   429

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

   430

        # warn user he has two left hands

   431

        if DesiredName != res:

   432

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

   433

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

   434

        return res

   435

   436

    def GetAllChannels(self):

   437

        AllChannels = []

   438

        for CTNInstance in self.CTNParent.IterChildren():

   439

            if CTNInstance != self:

   440

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

   441

        AllChannels.sort()

   442

        return AllChannels

   443

   444

    def FindNewIEC_Channel(self, DesiredChannel):

   445

        """

   446

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

   447

        @param DesiredChannel: The desired IEC channel (int)

   448

        """

   449

        # Get Current IEC channel

   450

        CurrentChannel = self.BaseParams.getIEC_Channel()

   451

        # Do nothing if no change

   452

        # if CurrentChannel == DesiredChannel: return CurrentChannel

   453

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

   454

        AllChannels = self.GetAllChannels()

   455

   456

        # Now, try to guess the nearest available channel

   457

        res = DesiredChannel

   458

        while res in AllChannels:  # While channel not free

   459

            if res < CurrentChannel:  # Want to go down ?

   460

                res -= 1  # Test for n-1

   461

                if res < 0:

   462

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

   463

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

   464

            else:  # Want to go up ?

   465

                res += 1  # Test for n-1

   466

        # Finally set IEC Channel

   467

        self.BaseParams.setIEC_Channel(res)

   468

        return res

   469

   470

    def GetContextualMenuItems(self):

   471

        return None

   472

   473

    def GetView(self, onlyopened=False):

   474

        if self._View is None and not onlyopened and self.EditorType is not None:

   475

            app_frame = self.GetCTRoot().AppFrame

   476

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

   477

   478

        return self._View