1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from xml.dom import minidom

    26

from types import StringType, UnicodeType, TupleType

    27

from lxml import etree

    28

from copy import deepcopy

    29

import os,sys,re

    30

import datetime

    31

from time import localtime

    32

from collections import OrderedDict, namedtuple

    33

    34

from plcopen import *

    35

from graphics.GraphicCommons import *

    36

from PLCGenerator import *

    37

    38

duration_model = re.compile("(?:([0-9]{1,2})h)?(?:([0-9]{1,2})m(?!s))?(?:([0-9]{1,2})s)?(?:([0-9]{1,3}(?:\.[0-9]*)?)ms)?")

    39

    40

ITEMS_EDITABLE = [ITEM_PROJECT,

    41

                  ITEM_POU,

    42

                  ITEM_VARIABLE,

    43

                  ITEM_TRANSITION,

    44

                  ITEM_ACTION,

    45

                  ITEM_CONFIGURATION,

    46

                  ITEM_RESOURCE,

    47

                  ITEM_DATATYPE

    48

                 ] = range(8)

    49

    50

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    51

                    ITEM_FUNCTION,

    52

                    ITEM_FUNCTIONBLOCK,

    53

                    ITEM_PROGRAM,

    54

                    ITEM_TRANSITIONS,

    55

                    ITEM_ACTIONS,

    56

                    ITEM_CONFIGURATIONS,

    57

                    ITEM_RESOURCES,

    58

                    ITEM_PROPERTIES

    59

                   ] = range(8, 17)

    60

    61

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    62

                  ITEM_VAR_GLOBAL,

    63

                  ITEM_VAR_EXTERNAL,

    64

                  ITEM_VAR_TEMP,

    65

                  ITEM_VAR_INPUT,

    66

                  ITEM_VAR_OUTPUT,

    67

                  ITEM_VAR_INOUT

    68

                 ] = range(17, 24)

    69

    70

VAR_CLASS_INFOS = {

    71

    "Local":    ("localVars",    ITEM_VAR_LOCAL),

    72

    "Global":   ("globalVars",   ITEM_VAR_GLOBAL),

    73

    "External": ("externalVars", ITEM_VAR_EXTERNAL),

    74

    "Temp":     ("tempVars",     ITEM_VAR_TEMP),

    75

    "Input":    ("inputVars",    ITEM_VAR_INPUT),

    76

    "Output":   ("outputVars",   ITEM_VAR_OUTPUT),

    77

    "InOut":    ("inOutVars",    ITEM_VAR_INOUT)}

    78

    79

POU_TYPES = {"program": ITEM_PROGRAM,

    80

             "functionBlock": ITEM_FUNCTIONBLOCK,

    81

             "function": ITEM_FUNCTION,

    82

            }

    83

    84

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    85

                   LOCATION_MODULE,

    86

                   LOCATION_GROUP,

    87

                   LOCATION_VAR_INPUT,

    88

                   LOCATION_VAR_OUTPUT,

    89

                   LOCATION_VAR_MEMORY] = range(6)

    90

    91

ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]

    92

    93

def GetUneditableNames():

    94

    _ = lambda x:x

    95

    return [_("User-defined POUs"), _("Functions"), _("Function Blocks"), 

    96

            _("Programs"), _("Data Types"), _("Transitions"), _("Actions"), 

    97

            _("Configurations"), _("Resources"), _("Properties")]

    98

UNEDITABLE_NAMES = GetUneditableNames()

    99

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

   100

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

   101

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   102

   103

#-------------------------------------------------------------------------------

   104

#                 Helper object for loading library in xslt stylesheets

   105

#-------------------------------------------------------------------------------

   106

   107

class LibraryResolver(etree.Resolver):

   108

   109

    def __init__(self, controller, debug=False):

   110

        self.Controller = controller

   111

        self.Debug = debug

   112

   113

    def resolve(self, url, pubid, context):

   114

        lib_name = os.path.basename(url)

   115

        if lib_name in ["project", "stdlib", "extensions"]:

   116

            lib_el = etree.Element(lib_name)

   117

            if lib_name == "project":

   118

                lib_el.append(deepcopy(self.Controller.GetProject(self.Debug)))

   119

            elif lib_name == "stdlib":

   120

                for lib in [StdBlockLibrary, AddnlBlockLibrary]:

   121

                    lib_el.append(deepcopy(lib))

   122

            else:

   123

                for ctn in self.Controller.ConfNodeTypes:

   124

                    lib_el.append(deepcopy(ctn["types"]))

   125

            return self.resolve_string(etree.tostring(lib_el), context)

   126

   127

#-------------------------------------------------------------------------------

   128

#           Helpers functions for translating list of arguments

   129

#                       from xslt to valid arguments

   130

#-------------------------------------------------------------------------------

   131

   132

_BoolValue = lambda x: x in ["true", "0"]

   133

   134

def _translate_args(translations, args):

   135

    return [translate(arg[0]) if len(arg) > 0 else None 

   136

            for translate, arg in

   137

            zip(translations, args)]

   138

   139

#-------------------------------------------------------------------------------

   140

#                 Helpers object for generating pou var list

   141

#-------------------------------------------------------------------------------

   142

   143

class _VariableInfos(object):

   144

    __slots__ = ["Name", "Class", "Option", "Location", "InitialValue", 

   145

                 "Edit", "Documentation", "Type", "Tree", "Number"]

   146

    def __init__(self, *args):

   147

        for attr, value in zip(self.__slots__, args):

   148

            setattr(self, attr, value if value is not None else "")

   149

    def copy(self):

   150

        return _VariableInfos(*[getattr(self, attr) for attr in self.__slots__])

   151

   152

class VariablesInfosFactory:

   153

   154

    def __init__(self, variables):

   155

        self.Variables = variables

   156

        self.TreeStack = []

   157

        self.Type = None

   158

        self.Dimensions = None

   159

   160

    def SetType(self, context, *args):

   161

        self.Type = args[0][0]

   162

   163

    def GetType(self):

   164

        if len(self.Dimensions) > 0:

   165

            return ("array", self.Type, self.Dimensions)

   166

        return self.Type

   167

   168

    def GetTree(self):

   169

        return (self.TreeStack.pop(-1), self.Dimensions)

   170

   171

    def AddDimension(self, context, *args):

   172

        self.Dimensions.append(tuple(

   173

            _translate_args([str] * 2, args)))

   174

   175

    def AddTree(self, context, *args):

   176

        self.TreeStack.append([])

   177

        self.Dimensions = []

   178

   179

    def AddVarToTree(self, context, *args):

   180

        var = (args[0][0], self.Type, self.GetTree())

   181

        self.TreeStack[-1].append(var)

   182

   183

    def AddVariable(self, context, *args):

   184

        self.Variables.append(_VariableInfos(*(_translate_args(

   185

            [str] * 5 + [_BoolValue] + [str], args) + 

   186

            [self.GetType(), self.GetTree()])))

   187

   188

#-------------------------------------------------------------------------------

   189

#            Helpers object for generating pou variable instance list

   190

#-------------------------------------------------------------------------------

   191

   194

        "configuration": ITEM_CONFIGURATION,

   195

        "resource": ITEM_RESOURCE,

   196

        "action": ITEM_ACTION,

   197

        "transition": ITEM_TRANSITION,

   240

   241

#-------------------------------------------------------------------------------

   242

#            Helpers object for generating instances path list

   243

#-------------------------------------------------------------------------------

   244

   245

class InstanceDefinition(etree.XSLTExtension):

   246

   247

    def __init__(self, controller, debug):

   248

        etree.XSLTExtension.__init__(self)

   249

        self.Controller = controller

   250

        self.Debug = debug

   251

   252

    def execute(self, context, self_node, input_node, output_parent):

   253

        instance_infos = etree.Element('infos')

   254

        self.process_children(context, instance_infos)

   255

   256

        pou_infos = self.Controller.GetPou(instance_infos.get("name"), self.Debug)

   257

        if pou_infos is not None:

   258

            pou_instance = etree.Element('pou_instance',

   259

                pou_path=instance_infos.get("path"))

   260

            pou_instance.append(deepcopy(pou_infos))

   261

            self.apply_templates(context, pou_instance, output_parent)

   262

            return

   263

   264

        datatype_infos = self.Controller.GetDataType(instance_infos.get("name"), self.Debug)

   265

        if datatype_infos is not None:

   266

            datatype_instance = etree.Element('datatype_instance',

   267

                datatype_path=instance_infos.get("path"))

   268

            datatype_instance.append(deepcopy(datatype_infos))

   269

            self.apply_templates(context, datatype_instance, output_parent)

   270

            return

   271

   272

instances_path_xslt = etree.parse(

   273

    os.path.join(ScriptDirectory, "plcopen", "instances_path.xslt"))

   274

   275

#-------------------------------------------------------------------------------

   276

#            Helpers object for generating instance tagname

   277

#-------------------------------------------------------------------------------

   278

   279

class InstanceTagName(etree.XSLTExtension):

   280

   281

    def __init__(self, controller):

   282

        etree.XSLTExtension.__init__(self)

   283

        self.Controller = controller

   284

   285

    def GetTagName(self, infos):

   286

        return ""

   287

   288

    def execute(self, context, self_node, input_node, output_parent):

   289

        tagname_infos = etree.Element('infos')

   290

        self.process_children(context, tagname_infos)

   291

        tagname = etree.Element('tagname')

   292

        tagname.text = self.GetTagName(tagname_infos)

   293

        try:

   294

            output_parent.append(tagname)

   295

        except:

   296

            pass

   297

   298

class ConfigTagName(InstanceTagName):

   299

   300

    def GetTagName(self, infos):

   301

        return self.Controller.ComputeConfigurationName(infos.get("name"))

   302

   303

class ResourceTagName(InstanceTagName):

   304

   305

    def GetTagName(self, infos):

   306

        return self.Controller.ComputeConfigurationResourceName(

   307

            infos.get("config_name"), infos.get("name"))

   308

   309

class PouTagName(InstanceTagName):

   310

   311

    def GetTagName(self, infos):

   312

        return self.Controller.ComputePouName(infos.get("name"))

   313

   314

class ActionTagName(InstanceTagName):

   315

   316

    def GetTagName(self, infos):

   317

        return self.Controller.ComputePouActionName(

   318

            infos.get("pou_name"), infos.get("name"))

   319

   320

class TransitionTagName(InstanceTagName):

   321

   322

    def GetTagName(self, infos):

   323

        return self.Controller.ComputePouTransitionName(

   324

            infos.get("pou_name"), infos.get("name"))

   325

   326

instance_tagname_xslt = etree.parse(

   327

    os.path.join(ScriptDirectory, "plcopen", "instance_tagname.xslt"))

   328

   329

#-------------------------------------------------------------------------------

   330

#           Helpers object for generating pou block instances list

   331

#-------------------------------------------------------------------------------

   332

   333

_Point = namedtuple("Point", ["x", "y"])

   334

   335

_BlockInstanceInfos = namedtuple("BlockInstanceInfos", 

   336

    ["type", "id", "x", "y", "width", "height", "specific_values", "inputs", "outputs"])

   337

   338

_BlockSpecificValues = (

   339

    namedtuple("BlockSpecificValues", 

   340

               ["name", "execution_order"]),

   341

    [str, int])

   342

_VariableSpecificValues = (

   343

    namedtuple("VariableSpecificValues", 

   344

               ["name", "value_type", "execution_order"]),

   345

    [str, str, int])

   346

_ConnectionSpecificValues = (

   347

    namedtuple("ConnectionSpecificValues", ["name"]),

   348

    [str])

   349

   350

_PowerRailSpecificValues = (

   351

    namedtuple("PowerRailSpecificValues", ["connectors"]),

   352

    [int])

   353

   354

_LDElementSpecificValues = (

   355

    namedtuple("LDElementSpecificValues", 

   356

               ["name", "negated", "edge", "storage", "execution_order"]),

   357

    [str, _BoolValue, str, str, int])

   358

   359

_DivergenceSpecificValues = (

   360

    namedtuple("DivergenceSpecificValues", ["connectors"]),

   361

    [int])

   362

   363

_SpecificValuesTuples = {

   364

    "comment": (

   365

        namedtuple("CommentSpecificValues", ["content"]),

   366

        [str]),

   367

    "input": _VariableSpecificValues,

   368

    "output": _VariableSpecificValues,

   369

    "inout": _VariableSpecificValues,

   370

    "connector": _ConnectionSpecificValues,

   371

    "continuation": _ConnectionSpecificValues,

   372

    "leftPowerRail": _PowerRailSpecificValues,

   373

    "rightPowerRail": _PowerRailSpecificValues,

   374

    "contact": _LDElementSpecificValues,

   375

    "coil": _LDElementSpecificValues,

   376

    "step": (

   377

        namedtuple("StepSpecificValues", ["name", "initial", "action"]),

   378

        [str, _BoolValue, lambda x: x]),

   379

    "transition": (

   380

        namedtuple("TransitionSpecificValues", 

   381

                   ["priority", "condition_type", "condition", "connection"]),

   382

        [int, str, str, lambda x: x]),

   383

    "selectionDivergence": _DivergenceSpecificValues,

   384

    "selectionConvergence": _DivergenceSpecificValues,

   385

    "simultaneousDivergence": _DivergenceSpecificValues,

   386

    "simultaneousConvergence": _DivergenceSpecificValues,

   387

    "jump": (

   388

        namedtuple("JumpSpecificValues", ["target"]),

   389

        [str]),

   390

    "actionBlock": (

   391

        namedtuple("ActionBlockSpecificValues", ["actions"]),

   392

        [lambda x: x]),

   393

}

   394

   395

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   396

    ["name", "negated", "edge", "position", "links"])

   397

   398

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   399

    ["refLocalId", "formalParameter", "points"])

   400

   401

class _ActionInfos(object):

   402

    __slots__ = ["qualifier", "type", "value", "duration", "indicator"]

   403

    def __init__(self, *args):

   404

        for attr, value in zip(self.__slots__, args):

   405

            setattr(self, attr, value if value is not None else "")

   406

    def copy(self):

   407

        return _ActionInfos(*[getattr(self, attr) for attr in self.__slots__])

   408

   409

class BlockInstanceFactory:

   410

   411

    def __init__(self, block_instances):

   412

        self.BlockInstances = block_instances

   413

        self.CurrentInstance = None

   414

        self.SpecificValues = None

   415

        self.CurrentConnection = None

   416

        self.CurrentLink = None

   417

   418

    def SetSpecificValues(self, context, *args):

   419

        self.SpecificValues = list(args)

   420

        self.CurrentInstance = None

   421

        self.CurrentConnection = None

   422

        self.CurrentLink = None

   423

   424

    def AddBlockInstance(self, context, *args):

   425

        specific_values_tuple, specific_values_translation = \

   426

            _SpecificValuesTuples.get(args[0][0], _BlockSpecificValues)

   427

   428

        if (args[0][0] == "step" and len(self.SpecificValues) < 3 or

   429

            args[0][0] == "transition" and len(self.SpecificValues) < 4):

   430

            self.SpecificValues.append([None])

   431

        elif args[0][0] == "actionBlock" and len(self.SpecificValues) < 1:

   432

            self.SpecificValues.append([[]])

   433

        specific_values = specific_values_tuple(*_translate_args(

   434

            specific_values_translation, self.SpecificValues))

   435

        self.SpecificValues = None

   436

   437

        self.CurrentInstance = _BlockInstanceInfos(

   438

            *(_translate_args([str] + [int] * 5, args) + 

   439

              [specific_values, [], []]))

   440

   441

        self.BlockInstances[self.CurrentInstance.id] = self.CurrentInstance

   442

   443

    def AddInstanceConnection(self, context, *args):

   444

        connection_args = _translate_args(

   445

            [str, str, _BoolValue, str, int, int], args)

   446

   447

        self.CurrentConnection = _InstanceConnectionInfos(

   448

            *(connection_args[1:4] + [

   449

                _Point(*connection_args[4:6]), []]))

   450

   451

        if self.CurrentInstance is not None:

   452

            if connection_args[0] == "input":

   453

                self.CurrentInstance.inputs.append(self.CurrentConnection)

   454

            else:

   455

                self.CurrentInstance.outputs.append(self.CurrentConnection)

   456

        else:

   457

            self.SpecificValues.append([self.CurrentConnection])

   458

   459

    def AddConnectionLink(self, context, *args):

   460

        self.CurrentLink = _ConnectionLinkInfos(

   461

            *(_translate_args([int, str], args) + [[]]))

   462

        self.CurrentConnection.links.append(self.CurrentLink)

   463

   464

    def AddLinkPoint(self, context, *args):

   465

        self.CurrentLink.points.append(_Point(

   466

            *_translate_args([int, int], args)))

   467

   468

    def AddAction(self, context, *args):

   469

        if len(self.SpecificValues) == 0:

   470

            self.SpecificValues.append([[]])

   471

        translated_args = _translate_args([str] * 5, args)

   472

        self.SpecificValues[0][0].append(_ActionInfos(*translated_args))

   473

   474

pou_block_instances_xslt = etree.parse(

   475

    os.path.join(ScriptDirectory, "plcopen", "pou_block_instances.xslt"))

   476

   477

#-------------------------------------------------------------------------------

   478

#                         Undo Buffer for PLCOpenEditor

   479

#-------------------------------------------------------------------------------

   480

   481

# Length of the buffer

   482

UNDO_BUFFER_LENGTH = 20

   483

   484

"""

   485

Class implementing a buffer of changes made on the current editing model

   486

"""

   487

class UndoBuffer:

   488

   489

    # Constructor initialising buffer

   490

    def __init__(self, currentstate, issaved = False):

   491

        self.Buffer = []

   492

        self.CurrentIndex = -1

   493

        self.MinIndex = -1

   494

        self.MaxIndex = -1

   495

        # if current state is defined

   496

        if currentstate:

   497

            self.CurrentIndex = 0

   498

            self.MinIndex = 0

   499

            self.MaxIndex = 0

   500

        # Initialising buffer with currentstate at the first place

   501

        for i in xrange(UNDO_BUFFER_LENGTH):

   502

            if i == 0: