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 builtins import str as text

    41

from past.builtins import execfile

    42

    43

from lxml import etree

    44

    45

from xmlclass import GenerateParserFromXSDstring

    46

from PLCControler import LOCATION_CONFNODE

    47

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    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 ConfNodePath(self):

   103

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

   104

   105

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

   106

        if not CTNName:

   107

            CTNName = self.CTNName()

   108

        if not project_path:

   109

            project_path = self.CTNParent.CTNPath()

   110

        return os.path.join(project_path,

   111

                            CTNName + NameTypeSeparator + self.CTNType)

   112

   113

    def CTNName(self):

   114

        return self.BaseParams.getName()

   115

   116

    def CTNEnabled(self):

   117

        return self.BaseParams.getEnabled()

   118

   119

    def CTNFullName(self):

   120

        parent = self.CTNParent.CTNFullName()

   121

        if parent != "":

   122

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

   123

        return self.BaseParams.getName()

   124

   125

    def CTNSearch(self, criteria):

   126

        # TODO match config's fields name and fields contents

   127

        return reduce(add, [

   128

            CTNChild.CTNSearch(criteria)

   129

            for CTNChild in self.IterChildren()])

   130

   131

    def GetIconName(self):

   132

        return None

   133

   134

    def CTNTestModified(self):

   135

        return self.ChangesToSave

   136

   137

    def ProjectTestModified(self):

   138

        """

   139

        recursively check modified status

   140

        """

   141

        if self.CTNTestModified():

   142

            return True

   143

   144

        for CTNChild in self.IterChildren():

   145

            if CTNChild.ProjectTestModified():

   146

                return True

   147

   148

        return False

   149

   150

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

   151

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

   152

   153

    def OnCTNSave(self, from_project_path=None):

   154

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

   155

        return True

   156

   157

    def GetParamsAttributes(self, path=None):

   158

        if path:

   159

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

   160

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

   161

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

   162

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

   163

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

   164

        else:

   165

            params = []

   166

            if self.CTNParams:

   167

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

   168

            return params

   169

   170

    def SetParamsAttribute(self, path, value):

   171

        self.ChangesToSave = True

   172

        # Filter IEC_Channel and Name, that have specific behavior

   173

        if path == "BaseParams.IEC_Channel":

   174

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

   175

            new_value = self.FindNewIEC_Channel(value)

   176

            if new_value != value:

   177

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

   178

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

   179

            return new_value, True

   180

        elif path == "BaseParams.Name":

   181

            res = self.FindNewName(value)

   182

            self.CTNRequestSave()

   183

            return res, True

   184

   185

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

   186

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

   187

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

   188

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

   189

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

   190

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

   191

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

   192

        return value, False

   193

   194

    def CTNMakeDir(self):

   195

        os.mkdir(self.CTNPath())

   196

   197

    def CTNRequestSave(self, from_project_path=None):

   198

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

   199

            # If confnode do not have corresponding directory

   200

            ctnpath = self.CTNPath()

   201

            if not os.path.isdir(ctnpath):

   202

                # Create it

   203

                os.mkdir(ctnpath)

   204

   205

            # generate XML for base XML parameters controller of the confnode

   206

            if self.MandatoryParams:

   207

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

   208

                BaseXMLFile.write(etree.tostring(

   209

                    self.MandatoryParams[1],

   210

                    pretty_print=True,

   211

                    xml_declaration=True,

   212

                    encoding='utf-8'))

   213

                BaseXMLFile.close()

   214

   215

            # generate XML for XML parameters controller of the confnode

   216

            if self.CTNParams:

   217

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

   218

                XMLFile.write(etree.tostring(

   219

                    self.CTNParams[1],

   220

                    pretty_print=True,

   221

                    xml_declaration=True,

   222

                    encoding='utf-8'))

   223

                XMLFile.close()

   224

   225

            # Call the confnode specific OnCTNSave method

   226

            result = self.OnCTNSave(from_project_path)

   227

            if not result:

   228

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

   229

   230

            # mark confnode as saved

   231

            self.ChangesToSave = False

   232

            # go through all children and do the same

   233

            for CTNChild in self.IterChildren():

   234

                CTNChildPath = None

   235

                if from_project_path is not None:

   236

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   237

                result = CTNChild.CTNRequestSave(CTNChildPath)

   238

                if result:

   239

                    return result

   240

        return None

   241

   242

    def CTNImport(self, src_CTNPath):

   243

        shutil.copytree(src_CTNPath, self.CTNPath)

   244

        return True

   245

   246

    def CTNGlobalInstances(self):

   247

        """

   248

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

   249

        """

   250

        return []

   251

   252

    def _GlobalInstances(self):

   253

        instances = self.CTNGlobalInstances()

   254

        for CTNChild in self.IECSortedChildren():

   255

            instances.extend(CTNChild._GlobalInstances())

   256

        return instances

   257

   258

    def CTNGenerate_C(self, buildpath, locations):

   259

        """

   260

        Generate C code

   261

        @param locations: List of complete variables locations \

   262

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

   263

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

   264

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

   265

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

   266

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

   267

            }, ...]

   268

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

   269

        """

   270

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

   271

        return [], "", False

   272

   273

    def _Generate_C(self, buildpath, locations):

   274

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

   275

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

   276

        gen_result = self.CTNGenerate_C(buildpath, locations)

   277

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   278

        extra_files = gen_result[3:]

   279

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

   280

        if CTNCFilesAndCFLAGS:

   281

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

   282

        else:

   283

            LocationCFilesAndCFLAGS = []

   284

   285

        # confnode asks for some LDFLAGS

   286

        LDFLAGS = []

   287

        if CTNLDFLAGS is not None:

   288

            # LDFLAGS can be either string

   289

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

   290

                LDFLAGS += [CTNLDFLAGS]

   291

            # or list of strings

   292

            elif isinstance(CTNLDFLAGS, list):

   293

                LDFLAGS += CTNLDFLAGS

   294

   295

        # recurse through all children, and stack their results

   296

        for CTNChild in self.IECSortedChildren():

   297

            new_location = CTNChild.GetCurrentLocation()

   298

            # How deep are we in the tree ?

   299

            depth = len(new_location)

   300

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   301

                CTNChild._Generate_C(

   302

                    # keep the same path

   303

                    buildpath,

   304

                    # filter locations that start with current IEC location

   305

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

   306

            # stack the result

   307

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   308

            LDFLAGS += _LDFLAGS

   309

            extra_files += _extra_files

   310

   311

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   312

   313

    def IterChildren(self):

   314

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

   315

            for CTNInstance in Children:

   316

                yield CTNInstance

   317

   318

    def IECSortedChildren(self):

   319

        # reorder children by IEC_channels

   320

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

   321

        if ordered:

   322

            ordered.sort()

   323

            return zip(*ordered)[1]

   324

        else:

   325

            return []

   326

   327

    def _GetChildBySomething(self, something, toks):

   328

        for CTNInstance in self.IterChildren():

   329

            # if match component of the name

   330

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

   331

                # if Name have other components

   332

                if len(toks) >= 2:

   333

                    # Recurse in order to find the latest object

   334

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

   335

                # No sub name -> found

   336

                return CTNInstance

   337

        # Not found

   338

        return None

   339

   340

    def GetChildByName(self, Name):

   341

        if Name:

   342

            toks = Name.split('.')

   343

            return self._GetChildBySomething("Name", toks)

   344

        else:

   345

            return self

   346

   347

    def GetChildByIECLocation(self, Location):

   348

        if Location:

   349

            return self._GetChildBySomething("IEC_Channel", Location)

   350

        else:

   351

            return self

   352

   353

    def GetCurrentLocation(self):

   354

        """

   355

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

   356

        """

   357

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

   358

   359

    def GetCurrentName(self):

   360

        """

   361

        @return:  String "ParentParentName.ParentName.Name"

   362

        """

   363

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

   364

   365

    def _GetCurrentName(self):

   366

        """

   367

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

   368

        """

   369

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

   370

   371

    def GetCTRoot(self):

   372

        return self.CTNParent.GetCTRoot()

   373

   374

    def GetFullIEC_Channel(self):

   375

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

   376

   377

    def GetLocations(self):

   378

        location = self.GetCurrentLocation()

   379

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

   380

   381

    def GetVariableLocationTree(self):

   382

        '''

   383

        This function is meant to be overridden by confnodes.

   384

   385

        It should returns an list of dictionaries

   386

   387

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

   388

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

   389

        '''

   390

        children = []

   391

        for child in self.IECSortedChildren():

   392

            children.append(child.GetVariableLocationTree())

   393

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

   394

                "type": LOCATION_CONFNODE,

   395

                "location": self.GetFullIEC_Channel(),

   396

                "children": children}

   397

   398

    def FindNewName(self, DesiredName):

   399

        """

   400

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

   401

        @param DesiredName: The desired Name (string)

   402

        """

   403

   404

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

   405

        AllNames = []

   406

        for CTNInstance in self.CTNParent.IterChildren():

   407

            if CTNInstance != self:

   408

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

   409

   410

        # Find a free name, eventually appending digit

   411

        res = DesiredName

   412

        if DesiredName.endswith("_0"):

   413

            BaseDesiredName = DesiredName[:-2]

   414

        else:

   415

            BaseDesiredName = DesiredName

   416

        suffix = 1

   417

        while res in AllNames:

   418

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

   419

            suffix += 1

   420

   421

        # Check previous confnode existance

   422

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

   423

        if not dontexist:

   424

            # Get old path

   425

            oldpath = self.CTNPath()

   426

        # Set the new name

   427

        self.BaseParams.setName(res)

   428

        # Rename confnode dir if exist

   429

        if not dontexist:

   430

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

   431

        # warn user he has two left hands

   432

        if DesiredName != res:

   433

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

   434

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

   435

        return res

   436

   437

    def GetAllChannels(self):

   438

        AllChannels = []

   439

        for CTNInstance in self.CTNParent.IterChildren():

   440

            if CTNInstance != self:

   441

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

   442

        AllChannels.sort()

   443

        return AllChannels

   444

   445

    def FindNewIEC_Channel(self, DesiredChannel):

   446

        """

   447

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

   448

        @param DesiredChannel: The desired IEC channel (int)

   449

        """

   450

        # Get Current IEC channel

   451

        CurrentChannel = self.BaseParams.getIEC_Channel()

   452

        # Do nothing if no change

   453

        # if CurrentChannel == DesiredChannel: return CurrentChannel

   454

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

   455

        AllChannels = self.GetAllChannels()

   456

   457

        # Now, try to guess the nearest available channel

   458

        res = DesiredChannel

   459

        while res in AllChannels:  # While channel not free

   460

            if res < CurrentChannel:  # Want to go down ?

   461

                res -= 1  # Test for n-1

   462

                if res < 0:

   463

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

   464

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

   465

            else:  # Want to go up ?

   466

                res += 1  # Test for n-1

   467

        # Finally set IEC Channel

   468

        self.BaseParams.setIEC_Channel(res)

   469

        return res

   470

   471

    def GetContextualMenuItems(self):

   472

        return None

   473

   474

    def GetView(self):

   475

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

   476

            app_frame = self.GetCTRoot().AppFrame

   477

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

   478