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 lxml import etree

    40

    41

from xmlclass import GenerateParserFromXSDstring

    42

    43

from PLCControler import LOCATION_CONFNODE

    44

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    45

    46

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

    47

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

    48

          <xsd:element name="BaseParams">

    49

            <xsd:complexType>

    50

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

    51

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

    52

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

    53

            </xsd:complexType>

    54

          </xsd:element>

    55

        </xsd:schema>""")

    56

    57

NameTypeSeparator = '@'

    58

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

    59

    60

    61

class ConfigTreeNode(object):

    62

    """

    63

    This class is the one that define confnodes.

    64

    """

    65

    66

    XSD = None

    67

    CTNChildrenTypes = []

    68

    CTNMaxCount = None

    69

    ConfNodeMethods = []

    70

    LibraryControler = None

    71

    EditorType = ConfTreeNodeEditor

    72

    IconPath = None

    73

    74

    def _AddParamsMembers(self):

    75

        self.CTNParams = None

    76

        if self.XSD:

    77

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    78

            obj = self.Parser.CreateRoot()

    79

            name = obj.getLocalTag()

    80

            self.CTNParams = (name, obj)

    81

            setattr(self, name, obj)

    82

    83

    def __init__(self):

    84

        # Create BaseParam

    85

        self.BaseParams = _BaseParamsParser.CreateRoot()

    86

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

    87

        self._AddParamsMembers()

    88

        self.Children = {}

    89

        self._View = None

    90

        # copy ConfNodeMethods so that it can be later customized

    91

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

    92

    93

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    94

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

    95

    96

    def ConfNodeXmlFilePath(self, CTNName=None):

    97

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

    98

    99

    def ConfNodePath(self):

   100

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

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

   123

        return None

   124

   125

    def CTNTestModified(self):

   126

        return self.ChangesToSave

   127

   128

    def ProjectTestModified(self):

   129

        """

   130

        recursively check modified status

   131

        """

   132

        if self.CTNTestModified():

   133

            return True

   134

   135

        for CTNChild in self.IterChildren():

   136

            if CTNChild.ProjectTestModified():

   137

                return True

   138

   139

        return False

   140

   141

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

   142

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

   143

   144

    def OnCTNSave(self, from_project_path=None):

   145

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

   146

        return True

   147

   148

    def GetParamsAttributes(self, path=None):

   149

        if path:

   150

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

   151

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

   152

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

   153

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

   154

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

   155

        else:

   156

            params = []

   157

            if self.CTNParams:

   158

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

   159

            return params

   160

   161

    def SetParamsAttribute(self, path, value):

   162

        self.ChangesToSave = True

   163

        # Filter IEC_Channel and Name, that have specific behavior

   164

        if path == "BaseParams.IEC_Channel":

   165

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

   166

            new_value = self.FindNewIEC_Channel(value)

   167

            if new_value != value:

   168

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

   169

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

   170

            return new_value, True

   171

        elif path == "BaseParams.Name":

   172

            res = self.FindNewName(value)

   173

            self.CTNRequestSave()

   174

            return res, True

   175

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

        return value, False

   184

   185

    def CTNMakeDir(self):

   186

        os.mkdir(self.CTNPath())

   187

   188

    def CTNRequestSave(self, from_project_path=None):

   189

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

   190

            # If confnode do not have corresponding directory

   191

            ctnpath = self.CTNPath()

   192

            if not os.path.isdir(ctnpath):

   193

                # Create it

   194

                os.mkdir(ctnpath)

   195

   196

            # generate XML for base XML parameters controller of the confnode

   197

            if self.MandatoryParams:

   198

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

   199

                BaseXMLFile.write(etree.tostring(

   200

                    self.MandatoryParams[1],

   201

                    pretty_print=True,

   202

                    xml_declaration=True,

   203

                    encoding='utf-8'))

   204

                BaseXMLFile.close()

   205

   206

            # generate XML for XML parameters controller of the confnode

   207

            if self.CTNParams:

   208

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

   209

                XMLFile.write(etree.tostring(

   210

                    self.CTNParams[1],

   211

                    pretty_print=True,

   212

                    xml_declaration=True,

   213

                    encoding='utf-8'))

   214

                XMLFile.close()

   215

   216

            # Call the confnode specific OnCTNSave method

   217

            result = self.OnCTNSave(from_project_path)

   218

            if not result:

   219

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

   220

   221

            # mark confnode as saved

   222

            self.ChangesToSave = False

   223

            # go through all children and do the same

   224

            for CTNChild in self.IterChildren():

   225

                CTNChildPath = None

   226

                if from_project_path is not None:

   227

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   228

                result = CTNChild.CTNRequestSave(CTNChildPath)

   229

                if result:

   230

                    return result

   231

        return None

   232

   233

    def CTNImport(self, src_CTNPath):

   234

        shutil.copytree(src_CTNPath, self.CTNPath)

   235

        return True

   236

   237

    def CTNGlobalInstances(self):

   238

        """

   239

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

   240

        """

   241

        return []

   242

   243

    def _GlobalInstances(self):

   244

        instances = self.CTNGlobalInstances()

   245

        for CTNChild in self.IECSortedChildren():

   246

            instances.extend(CTNChild._GlobalInstances())

   247

        return instances

   248

   249

    def CTNGenerate_C(self, buildpath, locations):

   250

        """

   251

        Generate C code

   252

        @param locations: List of complete variables locations \

   253

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

   254

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

   255

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

   256

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

   257

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

   258

            }, ...]

   259

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

   260

        """

   261

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

   262

        return [], "", False

   263

   264

    def _Generate_C(self, buildpath, locations):

   265

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

   266

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

   267

        gen_result = self.CTNGenerate_C(buildpath, locations)

   268

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   269

        extra_files = gen_result[3:]

   270

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

   271

        if CTNCFilesAndCFLAGS:

   272

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

   273

        else:

   274

            LocationCFilesAndCFLAGS = []

   275

   276

        # confnode asks for some LDFLAGS

   277

        if CTNLDFLAGS:

   278

            # LDFLAGS can be either string

   279

            if isinstance(CTNLDFLAGS, str):

   280

                LDFLAGS = [CTNLDFLAGS]

   281

            # or list of strings

   282

            elif isinstance(CTNLDFLAGS, list):

   283

                LDFLAGS = CTNLDFLAGS[:]

   284

        else:

   285

            LDFLAGS = []

   286

   287

        # recurse through all children, and stack their results

   288

        for CTNChild in self.IECSortedChildren():

   289

            new_location = CTNChild.GetCurrentLocation()

   290

            # How deep are we in the tree ?

   291

            depth = len(new_location)

   292

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   293

                CTNChild._Generate_C(

   294

                    # keep the same path

   295

                    buildpath,

   296

                    # filter locations that start with current IEC location

   297

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

   298

            # stack the result

   299

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   300

            LDFLAGS += _LDFLAGS

   301

            extra_files += _extra_files

   302

   303

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   304

   305

    def IterChildren(self):

   306

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

   307

            for CTNInstance in Children:

   308

                yield CTNInstance

   309

   310

    def IECSortedChildren(self):

   311

        # reorder children by IEC_channels

   312

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

   313

        if ordered:

   314

            ordered.sort()

   315

            return zip(*ordered)[1]

   316

        else:

   317

            return []

   318

   319

    def _GetChildBySomething(self, something, toks):

   320

        for CTNInstance in self.IterChildren():

   321

            # if match component of the name

   322

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

   323

                # if Name have other components

   324

                if len(toks) >= 2:

   325

                    # Recurse in order to find the latest object

   326

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

   327

                # No sub name -> found

   328

                return CTNInstance

   329

        # Not found

   330

        return None

   331

   332

    def GetChildByName(self, Name):

   333

        if Name:

   334

            toks = Name.split('.')

   335

            return self._GetChildBySomething("Name", toks)

   336

        else:

   337

            return self

   338

   339

    def GetChildByIECLocation(self, Location):

   340

        if Location:

   341

            return self._GetChildBySomething("IEC_Channel", Location)

   342

        else:

   343

            return self

   344

   345

    def GetCurrentLocation(self):

   346

        """

   347

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

   348

        """

   349

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

   350

   351

    def GetCurrentName(self):

   352

        """

   353

        @return:  String "ParentParentName.ParentName.Name"

   354

        """

   355

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

   356

   357

    def _GetCurrentName(self):

   358

        """

   359

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

   360

        """

   361

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

   362

   363

    def GetCTRoot(self):

   364

        return self.CTNParent.GetCTRoot()

   365

   366

    def GetFullIEC_Channel(self):

   367

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

   368

   369

    def GetLocations(self):

   370

        location = self.GetCurrentLocation()

   371

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

   372

   373

    def GetVariableLocationTree(self):

   374

        '''

   375

        This function is meant to be overridden by confnodes.

   376

   377

        It should returns an list of dictionaries

   378

   379

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

   380

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

   381

        '''

   382

        children = []

   383

        for child in self.IECSortedChildren():

   384

            children.append(child.GetVariableLocationTree())

   385

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

   386

                "type": LOCATION_CONFNODE,

   387

                "location": self.GetFullIEC_Channel(),

   388

                "children": children}

   389

   390

    def FindNewName(self, DesiredName):

   391

        """

   392

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

   393

        @param DesiredName: The desired Name (string)

   394

        """

   395

   396

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

   397

        AllNames = []

   398

        for CTNInstance in self.CTNParent.IterChildren():

   399

            if CTNInstance != self:

   400

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

   401

   402

        # Find a free name, eventually appending digit

   403

        res = DesiredName

   404

        if DesiredName.endswith("_0"):

   405

            BaseDesiredName = DesiredName[:-2]

   406

        else:

   407

            BaseDesiredName = DesiredName

   408

        suffix = 1

   409

        while res in AllNames:

   410

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

   411

            suffix += 1

   412

   413

        # Get old path

   414

        oldname = self.CTNPath()

   415

        # Check previous confnode existance

   416

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

   417

        # Set the new name

   418

        self.BaseParams.setName(res)

   419

        # Rename confnode dir if exist

   420

        if not dontexist:

   421

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

   422

        # warn user he has two left hands

   423

        if DesiredName != res:

   424

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

   425

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

   426

        return res

   427

   428

    def GetAllChannels(self):

   429

        AllChannels = []

   430

        for CTNInstance in self.CTNParent.IterChildren():

   431

            if CTNInstance != self:

   432

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

   433

        AllChannels.sort()

   434

        return AllChannels

   435

   436

    def FindNewIEC_Channel(self, DesiredChannel):

   437

        """

   438

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

   439

        @param DesiredChannel: The desired IEC channel (int)

   440

        """

   441

        # Get Current IEC channel

   442

        CurrentChannel = self.BaseParams.getIEC_Channel()

   443

        # Do nothing if no change

   444

        # if CurrentChannel == DesiredChannel: return CurrentChannel

   445

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

   446

        AllChannels = self.GetAllChannels()

   447

   448

        # Now, try to guess the nearest available channel

   449

        res = DesiredChannel

   450

        while res in AllChannels:  # While channel not free

   451

            if res < CurrentChannel:  # Want to go down ?

   452

                res -= 1  # Test for n-1

   453

                if res < 0:

   454

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

   455

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

   456

            else:  # Want to go up ?

   457

                res += 1  # Test for n-1

   458

        # Finally set IEC Channel

   459

        self.BaseParams.setIEC_Channel(res)

   460

        return res

   461

   462

    def GetContextualMenuItems(self):

   463

        return None

   464

   465

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

   466

        if self.EditorType is not None:

   467

            app_frame = self.GetCTRoot().AppFrame

   468

            if self._View is None and not onlyopened:

   469

   470

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

   471

   472

            if self._View is not None:

   473

                if name is None:

   474

                    name = self.CTNFullName()

   475

                app_frame.EditProjectElement(self._View, name)

   476

   477

            return self._View

   478

        return None