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

    40

from past.builtins import execfile

    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

    48

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

    49

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

    50

          <xsd:element name="BaseParams">

    51

            <xsd:complexType>

    52

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

    53

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

    54

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

    55

            </xsd:complexType>

    56

          </xsd:element>

    57

        </xsd:schema>""")

    58

    59

NameTypeSeparator = '@'

    60

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

    61

    62

    63

class ConfigTreeNode(object):

    64

    """

    65

    This class is the one that define confnodes.

    66

    """

    67

    68

    XSD = None

    69

    CTNChildrenTypes = []

    70

    CTNMaxCount = None

    71

    ConfNodeMethods = []

    72

    LibraryControler = None

    73

    EditorType = ConfTreeNodeEditor

    74

    IconPath = None

    75

    76

    def _AddParamsMembers(self):

    77

        self.CTNParams = None

    78

        if self.XSD:

    79

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    80

            obj = self.Parser.CreateRoot()

    81

            name = obj.getLocalTag()

    82

            self.CTNParams = (name, obj)

    83

            setattr(self, name, obj)

    84

    85

    def __init__(self):

    86

        # Create BaseParam

    87

        self.BaseParams = _BaseParamsParser.CreateRoot()

    88

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

    89

        self._AddParamsMembers()

    90

        self.Children = {}

    91

        self._View = None

    92

        # copy ConfNodeMethods so that it can be later customized

    93

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

    94

    95

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    96

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

    97

    98

    def ConfNodeXmlFilePath(self, CTNName=None):

    99

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

   100

   101

    def ConfNodePath(self):

   102

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

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

   125

        return None

   126

   127

    def CTNTestModified(self):

   128

        return self.ChangesToSave

   129

   130

    def ProjectTestModified(self):

   131

        """

   132

        recursively check modified status

   133

        """

   134

        if self.CTNTestModified():

   135

            return True

   136

   137

        for CTNChild in self.IterChildren():

   138

            if CTNChild.ProjectTestModified():

   139

                return True

   140

   141

        return False

   142

   143

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

   144

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

   145

   146

    def OnCTNSave(self, from_project_path=None):

   147

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

   148

        return True

   149

   150

    def GetParamsAttributes(self, path=None):

   151

        if path:

   152

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

   153

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

   154

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

   155

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

   156

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

   157

        else:

   158

            params = []

   159

            if self.CTNParams:

   160

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

   161

            return params

   162

   163

    def SetParamsAttribute(self, path, value):

   164

        self.ChangesToSave = True

   165

        # Filter IEC_Channel and Name, that have specific behavior

   166

        if path == "BaseParams.IEC_Channel":

   167

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

   168

            new_value = self.FindNewIEC_Channel(value)

   169

            if new_value != value:

   170

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

   171

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

   172

            return new_value, True

   173

        elif path == "BaseParams.Name":

   174

            res = self.FindNewName(value)

   175

            self.CTNRequestSave()

   176

            return res, True

   177

   178

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

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

        return value, False

   186

   187

    def CTNMakeDir(self):

   188

        os.mkdir(self.CTNPath())

   189

   190

    def CTNRequestSave(self, from_project_path=None):

   191

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

   192

            # If confnode do not have corresponding directory

   193

            ctnpath = self.CTNPath()

   194

            if not os.path.isdir(ctnpath):

   195

                # Create it

   196

                os.mkdir(ctnpath)

   197

   198

            # generate XML for base XML parameters controller of the confnode

   199

            if self.MandatoryParams:

   200

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

   201

                BaseXMLFile.write(etree.tostring(

   202

                    self.MandatoryParams[1],

   203

                    pretty_print=True,

   204

                    xml_declaration=True,

   205

                    encoding='utf-8'))

   206

                BaseXMLFile.close()

   207

   208

            # generate XML for XML parameters controller of the confnode

   209

            if self.CTNParams:

   210

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

   211

                XMLFile.write(etree.tostring(

   212

                    self.CTNParams[1],

   213

                    pretty_print=True,

   214

                    xml_declaration=True,

   215

                    encoding='utf-8'))

   216

                XMLFile.close()

   217

   218

            # Call the confnode specific OnCTNSave method

   219

            result = self.OnCTNSave(from_project_path)

   220

            if not result:

   221

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

   222

   223

            # mark confnode as saved

   224

            self.ChangesToSave = False

   225

            # go through all children and do the same

   226

            for CTNChild in self.IterChildren():

   227

                CTNChildPath = None

   228

                if from_project_path is not None:

   229

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   230

                result = CTNChild.CTNRequestSave(CTNChildPath)

   231

                if result:

   232

                    return result

   233

        return None

   234

   235

    def CTNImport(self, src_CTNPath):

   236

        shutil.copytree(src_CTNPath, self.CTNPath)

   237

        return True

   238

   239

    def CTNGlobalInstances(self):

   240

        """

   241

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

   242

        """

   243

        return []

   244

   245

    def _GlobalInstances(self):

   246

        instances = self.CTNGlobalInstances()

   247

        for CTNChild in self.IECSortedChildren():

   248

            instances.extend(CTNChild._GlobalInstances())

   249

        return instances

   250

   251

    def CTNGenerate_C(self, buildpath, locations):

   252

        """

   253

        Generate C code

   254

        @param locations: List of complete variables locations \

   255

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

   256

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

   257

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

   258

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

   259

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

   260

            }, ...]

   261

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

   262

        """

   263

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

   264

        return [], "", False

   265

   266

    def _Generate_C(self, buildpath, locations):

   267

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

   268

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

   269

        gen_result = self.CTNGenerate_C(buildpath, locations)

   270

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   271

        extra_files = gen_result[3:]

   272

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

   273

        if CTNCFilesAndCFLAGS:

   274

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

   275

        else:

   276

            LocationCFilesAndCFLAGS = []

   277

   278

        # confnode asks for some LDFLAGS

   279

        LDFLAGS = []

   280

        if CTNLDFLAGS is not None:

   281

            # LDFLAGS can be either string

   282

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

   283

                LDFLAGS += [CTNLDFLAGS]

   284

            # or list of strings

   285

            elif isinstance(CTNLDFLAGS, list):

   286

                LDFLAGS += CTNLDFLAGS

   287

   288

        # recurse through all children, and stack their results

   289

        for CTNChild in self.IECSortedChildren():

   290

            new_location = CTNChild.GetCurrentLocation()

   291

            # How deep are we in the tree ?

   292

            depth = len(new_location)

   293

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   294

                CTNChild._Generate_C(

   295

                    # keep the same path

   296

                    buildpath,

   297

                    # filter locations that start with current IEC location

   298

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

   299

            # stack the result

   300

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   301

            LDFLAGS += _LDFLAGS

   302

            extra_files += _extra_files

   303

   304

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   305

   306

    def IterChildren(self):

   307

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

   308

            for CTNInstance in Children:

   309

                yield CTNInstance

   310

   311

    def IECSortedChildren(self):

   312

        # reorder children by IEC_channels

   313

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

   314

        if ordered:

   315

            ordered.sort()

   316

            return zip(*ordered)[1]

   317

        else:

   318

            return []

   319

   320

    def _GetChildBySomething(self, something, toks):

   321

        for CTNInstance in self.IterChildren():

   322

            # if match component of the name

   323

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

   324

                # if Name have other components

   325

                if len(toks) >= 2:

   326

                    # Recurse in order to find the latest object

   327

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

   328

                # No sub name -> found

   329

                return CTNInstance

   330

        # Not found

   331

        return None

   332

   333

    def GetChildByName(self, Name):

   334

        if Name:

   335

            toks = Name.split('.')

   336

            return self._GetChildBySomething("Name", toks)

   337

        else:

   338

            return self

   339

   340

    def GetChildByIECLocation(self, Location):

   341

        if Location:

   342

            return self._GetChildBySomething("IEC_Channel", Location)

   343

        else:

   344

            return self

   345

   346

    def GetCurrentLocation(self):

   347

        """

   348

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

   349

        """

   350

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

   351

   352

    def GetCurrentName(self):

   353

        """

   354

        @return:  String "ParentParentName.ParentName.Name"

   355

        """

   356

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

   357

   358

    def _GetCurrentName(self):

   359

        """

   360

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

   361

        """

   362

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

   363

   364

    def GetCTRoot(self):

   365

        return self.CTNParent.GetCTRoot()

   366

   367

    def GetFullIEC_Channel(self):

   368

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

   369

   370

    def GetLocations(self):

   371

        location = self.GetCurrentLocation()

   372

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

   373

   374

    def GetVariableLocationTree(self):

   375

        '''

   376

        This function is meant to be overridden by confnodes.

   377

   378

        It should returns an list of dictionaries

   379

   380

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

   381

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

   382

        '''

   383

        children = []

   384

        for child in self.IECSortedChildren():

   385

            children.append(child.GetVariableLocationTree())

   386

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

   387

                "type": LOCATION_CONFNODE,

   388

                "location": self.GetFullIEC_Channel(),

   389

                "children": children}

   390

   391

    def FindNewName(self, DesiredName):

   392

        """

   393

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

   394

        @param DesiredName: The desired Name (string)

   395

        """

   396

   397

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

   398

        AllNames = []

   399

        for CTNInstance in self.CTNParent.IterChildren():

   400

            if CTNInstance != self:

   401

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

   402

   403

        # Find a free name, eventually appending digit

   404

        res = DesiredName

   405

        if DesiredName.endswith("_0"):

   406

            BaseDesiredName = DesiredName[:-2]

   407

        else:

   408

            BaseDesiredName = DesiredName

   409

        suffix = 1

   410

        while res in AllNames:

   411

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

   412

            suffix += 1

   413

   414

        # Check previous confnode existance

   415

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

   416

        if not dontexist:

   417

            # Get old path

   418

            oldpath = self.CTNPath()

   419

        # Set the new name

   420

        self.BaseParams.setName(res)

   421

        # Rename confnode dir if exist

   422

        if not dontexist:

   423

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

   424

        # warn user he has two left hands

   425

        if DesiredName != res:

   426

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

   427

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

   428

        return res

   429

   430

    def GetAllChannels(self):

   431

        AllChannels = []

   432

        for CTNInstance in self.CTNParent.IterChildren():

   433

            if CTNInstance != self:

   434

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

   435

        AllChannels.sort()

   436

        return AllChannels

   437

   438

    def FindNewIEC_Channel(self, DesiredChannel):

   439

        """

   440

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

   441

        @param DesiredChannel: The desired IEC channel (int)

   442

        """

   443

        # Get Current IEC channel

   444

        CurrentChannel = self.BaseParams.getIEC_Channel()

   445

        # Do nothing if no change

   446

        # if CurrentChannel == DesiredChannel: return CurrentChannel

   447

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

   448

        AllChannels = self.GetAllChannels()

   449

   450

        # Now, try to guess the nearest available channel

   451

        res = DesiredChannel

   452

        while res in AllChannels:  # While channel not free

   453

            if res < CurrentChannel:  # Want to go down ?

   454

                res -= 1  # Test for n-1

   455

                if res < 0:

   456

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

   457

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

   458

            else:  # Want to go up ?

   459

                res += 1  # Test for n-1

   460

        # Finally set IEC Channel

   461

        self.BaseParams.setIEC_Channel(res)

   462

        return res

   463

   464

    def GetContextualMenuItems(self):

   465

        return None

   466

   467

    def _OpenView(self, name=None, onlyopened=False):

   468

        if self.EditorType is not None:

   469

            app_frame = self.GetCTRoot().AppFrame

   470

            if self._View is None and not onlyopened:

   471

   472

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

   473

   474

            if self._View is not None:

   475

                if name is None:

   476

                    name = self.CTNFullName()

   477

                app_frame.EditProjectElement(self._View, name)

   478