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

import os

    35

import traceback

    36

import types

    37

import shutil

    38

from lxml import etree

    39

    40

from xmlclass import GenerateParserFromXSDstring

    41

    42

from PLCControler import LOCATION_CONFNODE

    43

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    44

    45

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

    46

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

    47

          <xsd:element name="BaseParams">

    48

            <xsd:complexType>

    49

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

    50

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

    51

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

    52

            </xsd:complexType>

    53

          </xsd:element>

    54

        </xsd:schema>""")

    55

    56

NameTypeSeparator = '@'

    57

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

    58

    59

    60

class ConfigTreeNode(object):

    61

    """

    62

    This class is the one that define confnodes.

    63

    """

    64

    65

    XSD = None

    66

    CTNChildrenTypes = []

    67

    CTNMaxCount = None

    68

    ConfNodeMethods = []

    69

    LibraryControler = None

    70

    EditorType = ConfTreeNodeEditor

    71

    IconPath = None

    72

    73

    def _AddParamsMembers(self):

    74

        self.CTNParams = None

    75

        if self.XSD:

    76

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    77

            obj = self.Parser.CreateRoot()

    78

            name = obj.getLocalTag()

    79

            self.CTNParams = (name, obj)

    80

            setattr(self, name, obj)

    81

    82

    def __init__(self):

    83

        # Create BaseParam

    84

        self.BaseParams = _BaseParamsParser.CreateRoot()

    85

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

    86

        self._AddParamsMembers()

    87

        self.Children = {}

    88

        self._View = None

    89

        # copy ConfNodeMethods so that it can be later customized

    90

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

    91

    92

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    93

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

    94

    95

    def ConfNodeXmlFilePath(self, CTNName=None):

    96

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

    97

    98

    def ConfNodePath(self):

    99

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

   100

   101

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

   102

        if not CTNName:

   103

            CTNName = self.CTNName()

   104

        if not project_path:

   105

            project_path = self.CTNParent.CTNPath()

   106

        return os.path.join(project_path,

   107

                            CTNName + NameTypeSeparator + self.CTNType)

   108

   109

    def CTNName(self):

   110

        return self.BaseParams.getName()

   111

   112

    def CTNEnabled(self):

   113

        return self.BaseParams.getEnabled()

   114

   115

    def CTNFullName(self):

   116

        parent = self.CTNParent.CTNFullName()

   117

        if parent != "":

   118

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

   119

        return self.BaseParams.getName()

   120

   121

    def GetIconName(self):

   122

        return None

   123

   124

    def CTNTestModified(self):

   125

        return self.ChangesToSave

   126

   127

    def ProjectTestModified(self):

   128

        """

   129

        recursively check modified status

   130

        """

   131

        if self.CTNTestModified():

   132

            return True

   133

   134

        for CTNChild in self.IterChildren():

   135

            if CTNChild.ProjectTestModified():

   136

                return True

   137

   138

        return False

   139

   140

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

   141

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

   142

   143

    def OnCTNSave(self, from_project_path=None):

   144

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

   145

        return True

   146

   147

    def GetParamsAttributes(self, path=None):

   148

        if path:

   149

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

   150

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

   151

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

   152

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

   153

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

   154

        else:

   155

            params = []

   156

            if self.CTNParams:

   157

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

   158

            return params

   159

   160

    def SetParamsAttribute(self, path, value):

   161

        self.ChangesToSave = True

   162

        # Filter IEC_Channel and Name, that have specific behavior

   163

        if path == "BaseParams.IEC_Channel":

   164

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

   165

            new_value = self.FindNewIEC_Channel(value)

   166

            if new_value != value:

   167

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

   168

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

   169

            return new_value, True

   170

        elif path == "BaseParams.Name":

   171

            res = self.FindNewName(value)

   172

            self.CTNRequestSave()

   173

            return res, True

   174

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

        return value, False

   183

   184

    def CTNMakeDir(self):

   185

        os.mkdir(self.CTNPath())

   186

   187

    def CTNRequestSave(self, from_project_path=None):

   188

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

   189

            # If confnode do not have corresponding directory

   190

            ctnpath = self.CTNPath()

   191

            if not os.path.isdir(ctnpath):

   192

                # Create it

   193

                os.mkdir(ctnpath)

   194

   195

            # generate XML for base XML parameters controller of the confnode

   196

            if self.MandatoryParams:

   197

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

   198

                BaseXMLFile.write(etree.tostring(

   199

                    self.MandatoryParams[1],

   200

                    pretty_print=True,

   201

                    xml_declaration=True,

   202

                    encoding='utf-8'))

   203

                BaseXMLFile.close()

   204

   205

            # generate XML for XML parameters controller of the confnode

   206

            if self.CTNParams:

   207

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

   208

                XMLFile.write(etree.tostring(

   209

                    self.CTNParams[1],

   210

                    pretty_print=True,

   211

                    xml_declaration=True,

   212

                    encoding='utf-8'))

   213

                XMLFile.close()

   214

   215

            # Call the confnode specific OnCTNSave method

   216

            result = self.OnCTNSave(from_project_path)

   217

            if not result:

   218

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

   219

   220

            # mark confnode as saved

   221

            self.ChangesToSave = False

   222

            # go through all children and do the same

   223

            for CTNChild in self.IterChildren():

   224

                CTNChildPath = None

   225

                if from_project_path is not None:

   226

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   227

                result = CTNChild.CTNRequestSave(CTNChildPath)

   228

                if result:

   229

                    return result

   230

        return None

   231

   232

    def CTNImport(self, src_CTNPath):

   233

        shutil.copytree(src_CTNPath, self.CTNPath)

   234

        return True

   235

   236

    def CTNGlobalInstances(self):

   237

        """

   238

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

   239

        """

   240

        return []

   241

   242

    def _GlobalInstances(self):

   243

        instances = self.CTNGlobalInstances()

   244

        for CTNChild in self.IECSortedChildren():

   245

            instances.extend(CTNChild._GlobalInstances())

   246

        return instances

   247

   248

    def CTNGenerate_C(self, buildpath, locations):

   249

        """

   250

        Generate C code

   251

        @param locations: List of complete variables locations \

   252

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

   253

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

   254

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

   255

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

   256

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

   257

            }, ...]

   258

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

   259

        """

   260

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

   261

        return [], "", False

   262

   263

    def _Generate_C(self, buildpath, locations):

   264

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

   265

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

   266

        gen_result = self.CTNGenerate_C(buildpath, locations)

   267

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   268

        extra_files = gen_result[3:]

   269

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

   270

        if CTNCFilesAndCFLAGS:

   271

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

   272

        else:

   273

            LocationCFilesAndCFLAGS = []

   274

   275

        # confnode asks for some LDFLAGS

   276

        if CTNLDFLAGS:

   277

            # LDFLAGS can be either string

   278

            if isinstance(CTNLDFLAGS, str):

   279

                LDFLAGS = [CTNLDFLAGS]

   280

            # or list of strings

   281

            elif isinstance(CTNLDFLAGS, list):

   282

                LDFLAGS = CTNLDFLAGS[:]

   283

        else:

   284

            LDFLAGS = []

   285

   286

        # recurse through all children, and stack their results

   287

        for CTNChild in self.IECSortedChildren():

   288

            new_location = CTNChild.GetCurrentLocation()

   289

            # How deep are we in the tree ?

   290

            depth = len(new_location)

   291

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   292

                CTNChild._Generate_C(

   293

                    # keep the same path

   294

                    buildpath,

   295

                    # filter locations that start with current IEC location

   296

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

   297

            # stack the result

   298

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   299

            LDFLAGS += _LDFLAGS

   300

            extra_files += _extra_files

   301

   302

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   303

   304

    def IterChildren(self):

   305

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

   306

            for CTNInstance in Children:

   307

                yield CTNInstance

   308

   309

    def IECSortedChildren(self):

   310

        # reorder children by IEC_channels

   311

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

   312

        if ordered:

   313

            ordered.sort()

   314

            return zip(*ordered)[1]

   315

        else:

   316

            return []

   317

   318

    def _GetChildBySomething(self, something, toks):

   319

        for CTNInstance in self.IterChildren():

   320

            # if match component of the name

   321

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

   322

                # if Name have other components

   323

                if len(toks) >= 2:

   324

                    # Recurse in order to find the latest object

   325

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

   326

                # No sub name -> found

   327

                return CTNInstance

   328

        # Not found

   329

        return None

   330

   331

    def GetChildByName(self, Name):

   332

        if Name:

   333

            toks = Name.split('.')

   334

            return self._GetChildBySomething("Name", toks)

   335

        else:

   336

            return self

   337

   338

    def GetChildByIECLocation(self, Location):

   339

        if Location:

   340

            return self._GetChildBySomething("IEC_Channel", Location)

   341

        else:

   342

            return self

   343

   344

    def GetCurrentLocation(self):

   345

        """

   346

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

   347

        """

   348

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

   349

   350

    def GetCurrentName(self):

   351

        """

   352

        @return:  String "ParentParentName.ParentName.Name"

   353

        """

   354

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

   355

   356

    def _GetCurrentName(self):

   357

        """

   358

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

   359

        """

   360

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

   361

   362

    def GetCTRoot(self):

   363

        return self.CTNParent.GetCTRoot()

   364

   365

    def GetFullIEC_Channel(self):

   366

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

   367

   368

    def GetLocations(self):

   369

        location = self.GetCurrentLocation()

   370

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

   371

   372

    def GetVariableLocationTree(self):

   373

        '''

   374

        This function is meant to be overridden by confnodes.

   375

   376

        It should returns an list of dictionaries

   377

   378

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

   379

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

   380

        '''

   381

        children = []

   382

        for child in self.IECSortedChildren():

   383

            children.append(child.GetVariableLocationTree())

   384

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

   385

                "type": LOCATION_CONFNODE,

   386

                "location": self.GetFullIEC_Channel(),

   387

                "children": children}

   388

   389

    def FindNewName(self, DesiredName):

   390

        """

   391

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

   392

        @param DesiredName: The desired Name (string)

   393

        """

   394

   395

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

   396

        AllNames = []

   397

        for CTNInstance in self.CTNParent.IterChildren():

   398

            if CTNInstance != self:

   399

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

   400

   401

        # Find a free name, eventually appending digit

   402

        res = DesiredName

   403

        if DesiredName.endswith("_0"):

   404

            BaseDesiredName = DesiredName[:-2]

   405

        else:

   406

            BaseDesiredName = DesiredName

   407

        suffix = 1

   408

        while res in AllNames:

   409

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

   410

            suffix += 1

   411

   412

        # Get old path

   413

        oldname = self.CTNPath()

   414

        # Check previous confnode existance

   415

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

   416

        # Set the new name

   417

        self.BaseParams.setName(res)

   418

        # Rename confnode dir if exist

   419

        if not dontexist:

   420

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

   421

        # warn user he has two left hands

   422

        if DesiredName != res:

   423

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

   424

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

   425

        return res

   426

   427

    def GetAllChannels(self):

   428

        AllChannels = []

   429

        for CTNInstance in self.CTNParent.IterChildren():

   430

            if CTNInstance != self:

   431

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

   432

        AllChannels.sort()

   433

        return AllChannels

   434

   435

    def FindNewIEC_Channel(self, DesiredChannel):

   436

        """

   437

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

   438

        @param DesiredChannel: The desired IEC channel (int)

   439

        """

   440

        # Get Current IEC channel

   441

        CurrentChannel = self.BaseParams.getIEC_Channel()

   442

        # Do nothing if no change

   443

        # if CurrentChannel == DesiredChannel: return CurrentChannel

   444

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

   445

        AllChannels = self.GetAllChannels()

   446

   447

        # Now, try to guess the nearest available channel

   448

        res = DesiredChannel

   449

        while res in AllChannels:  # While channel not free

   450

            if res < CurrentChannel:  # Want to go down ?

   451

                res -= 1  # Test for n-1

   452

                if res < 0:

   453

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

   454

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

   455

            else:  # Want to go up ?

   456

                res += 1  # Test for n-1

   457

        # Finally set IEC Channel

   458

        self.BaseParams.setIEC_Channel(res)

   459

        return res

   460

   461

    def GetContextualMenuItems(self):

   462

        return None

   463

   464

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

   465

        if self.EditorType is not None:

   466

            app_frame = self.GetCTRoot().AppFrame

   467

            if self._View is None and not onlyopened:

   468

   469

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

   470

   471

            if self._View is not None:

   472

                if name is None:

   473

                    name = self.CTNFullName()

   474

                app_frame.EditProjectElement(self._View, name)

   475

   476

            return self._View

   477

        return None

   478