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

    50

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

    51

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

    52

          <xsd:element name="BaseParams">

    53

            <xsd:complexType>

    54

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

    55

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

    56

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

    57

            </xsd:complexType>

    58

          </xsd:element>

    59

        </xsd:schema>""")

    60

    61

NameTypeSeparator = '@'

    62

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

    63

    64

    65

class ConfigTreeNode(object):

    66

    """

    67

    This class is the one that define confnodes.

    68

    """

    69

    70

    XSD = None

    71

    CTNChildrenTypes = []

    72

    CTNMaxCount = None

    73

    ConfNodeMethods = []

    74

    LibraryControler = None

    75

    EditorType = ConfTreeNodeEditor

    76

    IconPath = None

    77

    78

    def _AddParamsMembers(self):

    79

        self.CTNParams = None

    80

        if self.XSD:

    81

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    82

            obj = self.Parser.CreateRoot()

    83

            name = obj.getLocalTag()

    84

            self.CTNParams = (name, obj)

    85

            setattr(self, name, obj)

    86

    87

    def __init__(self):

    88

        # Create BaseParam

    89

        self.BaseParams = _BaseParamsParser.CreateRoot()

    90

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

    91

        self._AddParamsMembers()

    92

        self.Children = {}

    93

        self._View = None

    94

        # copy ConfNodeMethods so that it can be later customized

    95

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

    96

    97

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    98

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

    99

   100

    def ConfNodeXmlFilePath(self, CTNName=None):

   101

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

   102

   103

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

   104

        if not CTNName:

   105

            CTNName = self.CTNName()

   106

        if not project_path:

   107

            project_path = self.CTNParent.CTNPath()

   108

        return os.path.join(project_path,

   109

                            CTNName + NameTypeSeparator + self.CTNType)

   110

   111

    def CTNName(self):

   112

        return self.BaseParams.getName()

   113

   114

    def CTNEnabled(self):

   115

        return self.BaseParams.getEnabled()

   116

   117

    def CTNFullName(self):

   118

        parent = self.CTNParent.CTNFullName()

   119

        if parent != "":

   120

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

   121

        return self.BaseParams.getName()

   122

   123

    def CTNSearch(self, criteria):

   124

        # TODO match config's fields name and fields contents

   125

        return reduce(add, [

   126

            CTNChild.CTNSearch(criteria)

   127

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

   128

   129

    def GetIconName(self):

   130

        return None

   131

   132

    def CTNTestModified(self):

   133

        return self.ChangesToSave

   134

   135

    def ProjectTestModified(self):

   136

        """

   137

        recursively check modified status

   138

        """

   139

        if self.CTNTestModified():

   140

            return True

   141

   142

        for CTNChild in self.IterChildren():

   143

            if CTNChild.ProjectTestModified():

   144

                return True

   145

   146

        return False

   147

   148

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

   149

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

   150

   151

    def OnCTNSave(self, from_project_path=None):

   152

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

   153

        return True

   154

   155

    def GetParamsAttributes(self, path=None):

   156

        if path:

   157

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

   158

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

   159

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

   160

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

   161

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

   162

        else:

   163

            params = []

   164

            if self.CTNParams:

   165

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

   166

            return params

   167

   168

    def SetParamsAttribute(self, path, value):

   169

        self.ChangesToSave = True

   170

        # Filter IEC_Channel and Name, that have specific behavior

   171

        if path == "BaseParams.IEC_Channel":

   172

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

   173

            new_value = self.FindNewIEC_Channel(value)

   174

            if new_value != value:

   175

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

   176

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

   177

            return new_value, True

   178

        elif path == "BaseParams.Name":

   179

            res = self.FindNewName(value)

   180

            self.CTNRequestSave()

   181

            return res, True

   182

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

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

   190

        return value, False

   191

   192

    def CTNMakeDir(self):

   193

        os.mkdir(self.CTNPath())

   194

   195

    def CTNRequestSave(self, from_project_path=None):

   196

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

   197

            # If confnode do not have corresponding directory

   198

            ctnpath = self.CTNPath()

   199

            if not os.path.isdir(ctnpath):

   200

                # Create it

   201

                os.mkdir(ctnpath)

   202

   203

            # generate XML for base XML parameters controller of the confnode

   204

            if self.MandatoryParams:

   205

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

   206

                BaseXMLFile.write(etree.tostring(

   207

                    self.MandatoryParams[1],

   208

                    pretty_print=True,

   209

                    xml_declaration=True,

   210

                    encoding='utf-8'))

   211

                BaseXMLFile.close()

   212

   213

            # generate XML for XML parameters controller of the confnode

   214

            if self.CTNParams:

   215

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

   216

                XMLFile.write(etree.tostring(

   217

                    self.CTNParams[1],

   218

                    pretty_print=True,

   219

                    xml_declaration=True,

   220

                    encoding='utf-8'))

   221

                XMLFile.close()

   222

   223

            # Call the confnode specific OnCTNSave method

   224

            result = self.OnCTNSave(from_project_path)

   225

            if not result:

   226

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

   227

   228

            # mark confnode as saved

   229

            self.ChangesToSave = False

   230

            # go through all children and do the same

   231

            for CTNChild in self.IterChildren():

   232

                CTNChildPath = None

   233

                if from_project_path is not None:

   234

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   235

                result = CTNChild.CTNRequestSave(CTNChildPath)

   236

                if result:

   237

                    return result

   238

        return None

   239

   240

    def CTNImport(self, src_CTNPath):

   241

        shutil.copytree(src_CTNPath, self.CTNPath)

   242

        return True

   243

   244

    def CTNGlobalInstances(self):

   245

        """

   246

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

   247

        """

   248

        return []

   249

   250

    def _GlobalInstances(self):

   251

        instances = self.CTNGlobalInstances()

   252

        for CTNChild in self.IECSortedChildren():

   253

            instances.extend(CTNChild._GlobalInstances())

   254

        return instances

   255

   256

    def CTNGenerate_C(self, buildpath, locations):

   257

        """

   258

        Generate C code

   259

        @param locations: List of complete variables locations \

   260

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

   261

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

   262

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

   263

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

   264

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

   265

            }, ...]

   266

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

   267

        """

   268

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

   269

        return [], "", False

   270

   271

    def _Generate_C(self, buildpath, locations):

   272

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

   273

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

   274

        gen_result = self.CTNGenerate_C(buildpath, locations)

   275

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   276

        extra_files = gen_result[3:]

   277

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

   278

        if CTNCFilesAndCFLAGS:

   279

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

   280

        else:

   281

            LocationCFilesAndCFLAGS = []

   282

   283

        # confnode asks for some LDFLAGS

   284

        LDFLAGS = []

   285

        if CTNLDFLAGS is not None:

   286

            # LDFLAGS can be either string

   287

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

   288

                LDFLAGS += [CTNLDFLAGS]

   289

            # or list of strings

   290

            elif isinstance(CTNLDFLAGS, list):

   291

                LDFLAGS += CTNLDFLAGS

   292

   293

        # recurse through all children, and stack their results

   294

        for CTNChild in self.IECSortedChildren():

   295

            new_location = CTNChild.GetCurrentLocation()

   296

            # How deep are we in the tree ?

   297

            depth = len(new_location)

   298

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   299

                CTNChild._Generate_C(

   300

                    # keep the same path

   301

                    buildpath,

   302

                    # filter locations that start with current IEC location

   303

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

   304

            # stack the result

   305

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   306

            LDFLAGS += _LDFLAGS

   307

            extra_files += _extra_files

   308

   309

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   310

   311

    def IterChildren(self):

   312

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

   313

            for CTNInstance in Children:

   314

                yield CTNInstance

   315

   316

    def IECSortedChildren(self):

   317

        # reorder children by IEC_channels

   318

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

   319

        if ordered:

   320

            ordered.sort()

   321

            return zip(*ordered)[1]

   322

        else:

   323

            return []

   324

   325

    def _GetChildBySomething(self, something, toks):

   326

        for CTNInstance in self.IterChildren():

   327

            # if match component of the name

   328

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

   329

                # if Name have other components

   330

                if len(toks) >= 2:

   331

                    # Recurse in order to find the latest object

   332

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

   333

                # No sub name -> found

   334

                return CTNInstance

   335

        # Not found

   336

        return None

   337

   338

    def GetChildByName(self, Name):

   339

        if Name:

   340

            toks = Name.split('.')

   341

            return self._GetChildBySomething("Name", toks)

   342

        else:

   343

            return self

   344

   345

    def GetChildByIECLocation(self, Location):

   346

        if Location:

   347

            return self._GetChildBySomething("IEC_Channel", Location)

   348

        else:

   349

            return self

   350

   351

    def GetCurrentLocation(self):

   352

        """

   353

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

   354

        """

   355

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

   356

   357

    def GetCurrentName(self):

   358

        """

   359

        @return:  String "ParentParentName.ParentName.Name"

   360

        """

   361

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

   362

   363

    def _GetCurrentName(self):

   364

        """

   365

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

   366

        """

   367

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

   368

   369

    def GetCTRoot(self):

   370

        return self.CTNParent.GetCTRoot()

   371

   372

    def GetFullIEC_Channel(self):

   373

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

   374

   375

    def GetLocations(self):

   376

        location = self.GetCurrentLocation()

   377

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

   378

   379

    def GetVariableLocationTree(self):

   380

        '''

   381

        This function is meant to be overridden by confnodes.

   382

   383

        It should returns an list of dictionaries

   384

   385

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

   386

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

   387

        '''

   388

        children = []

   389

        for child in self.IECSortedChildren():

   390

            children.append(child.GetVariableLocationTree())

   391

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

   392

                "type": LOCATION_CONFNODE,

   393

                "location": self.GetFullIEC_Channel(),

   394

                "children": children}

   395

   396

    def FindNewName(self, DesiredName):

   397

        """

   398

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

   399

        @param DesiredName: The desired Name (string)

   400

        """

   401

   402

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

   403

        AllNames = []

   404

        for CTNInstance in self.CTNParent.IterChildren():

   405

            if CTNInstance != self:

   406

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

   407

   408

        # Find a free name, eventually appending digit

   409

        res = DesiredName

   410

        if DesiredName.endswith("_0"):

   411

            BaseDesiredName = DesiredName[:-2]

   412

        else:

   413

            BaseDesiredName = DesiredName

   414

        suffix = 1

   415

        while res in AllNames:

   416

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

   417

            suffix += 1

   418

   419

        # Check previous confnode existance

   420

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

   421

        if not dontexist:

   422

            # Get old path

   423

            oldpath = self.CTNPath()

   424

        # Set the new name

   425

        self.BaseParams.setName(res)

   426

        # Rename confnode dir if exist

   427

        if not dontexist:

   428

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

   429

        # warn user he has two left hands

   430

        if DesiredName != res:

   431

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

   432

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

   433

        return res

   434

   435

    def GetAllChannels(self):

   436

        AllChannels = []

   437

        for CTNInstance in self.CTNParent.IterChildren():

   438

            if CTNInstance != self:

   439

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

   440

        AllChannels.sort()

   441

        return AllChannels

   442

   443

    def FindNewIEC_Channel(self, DesiredChannel):

   444

        """

   445

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

   446

        @param DesiredChannel: The desired IEC channel (int)

   447

        """

   448

        # Get Current IEC channel

   449

        CurrentChannel = self.BaseParams.getIEC_Channel()

   450

        # Do nothing if no change

   451

        # if CurrentChannel == DesiredChannel: return CurrentChannel

   452

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

   453

        AllChannels = self.GetAllChannels()

   454

   455

        # Now, try to guess the nearest available channel

   456

        res = DesiredChannel

   457

        while res in AllChannels:  # While channel not free

   458

            if res < CurrentChannel:  # Want to go down ?

   459

                res -= 1  # Test for n-1

   460

                if res < 0:

   461

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

   462

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

   463

            else:  # Want to go up ?

   464

                res += 1  # Test for n-1

   465

        # Finally set IEC Channel

   466

        self.BaseParams.setIEC_Channel(res)

   467

        return res

   468

   469

    def GetContextualMenuItems(self):

   470

        return None

   471

   472

    def GetView(self):

   473

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

   474

            app_frame = self.GetCTRoot().AppFrame

   475

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

   476

   477

        return self._View

   478