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

from __future__ import absolute_import

    28

import math

    29

from time import time as gettime

    30

from types import TupleType

    31

from threading import Lock

    32

    33

import wx

    34

from six.moves import xrange

    35

    36

from plcopen.structures import *

    37

from plcopen.types_enums import ComputePouName

    38

from PLCControler import ITEM_VAR_LOCAL, ITEM_POU, ITEM_PROGRAM, ITEM_FUNCTIONBLOCK

    39

    40

from graphics.GraphicCommons import *

    41

from graphics.FBD_Objects import *

    42

from graphics.LD_Objects import *

    43

from graphics.SFC_Objects import *

    44

from graphics.RubberBand import RubberBand

    45

from graphics.DebugDataConsumer import DebugDataConsumer

    46

    47

from dialogs import *

    48

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    49

from editors.EditorPanel import EditorPanel

    50

    51

SCROLLBAR_UNIT = 10

    52

WINDOW_BORDER = 10

    53

SCROLL_ZONE = 10

    54

    55

CURSORS = None

    56

SFC_Objects = (SFC_Step, SFC_ActionBlock, SFC_Transition, SFC_Divergence, SFC_Jump)

    57

    58

    59

def ResetCursors():

    60

    global CURSORS

    61

    if CURSORS is None:

    62

        CURSORS = [wx.NullCursor,

    63

                   wx.StockCursor(wx.CURSOR_HAND),

    64

                   wx.StockCursor(wx.CURSOR_SIZENWSE),

    65

                   wx.StockCursor(wx.CURSOR_SIZENESW),

    66

                   wx.StockCursor(wx.CURSOR_SIZEWE),

    67

                   wx.StockCursor(wx.CURSOR_SIZENS)]

    68

    69

    70

def AppendMenu(parent, help, id, kind, text):

    71

    parent.Append(help=help, id=id, kind=kind, text=text)

    72

    73

    74

if wx.Platform == '__WXMSW__':

    75

    faces = {

    76

        'times': 'Times New Roman',

    77

        'mono':  'Courier New',

    78

        'helv':  'Arial',

    79

        'other': 'Comic Sans MS',

    80

        'size':  10,

    81

    }

    82

else:

    83

    faces = {

    84

        'times': 'Times',

    85

        'mono':  'Courier',

    86

        'helv':  'Helvetica',

    87

        'other': 'new century schoolbook',

    88

        'size':  10,

    89

    }

    90

    91

if wx.Platform == '__WXMSW__':

    92

    MAX_ZOOMIN = 4

    93

else:

    94

    MAX_ZOOMIN = 7

    95

ZOOM_FACTORS = [math.sqrt(2) ** x for x in xrange(-6, MAX_ZOOMIN)]

    96

    97

    98

def GetVariableCreationFunction(variable_type):

    99

    def variableCreationFunction(viewer, id, specific_values):

   100

        return FBD_Variable(viewer,

   101

                            variable_type,

   102

                            specific_values.name,

   103

                            specific_values.value_type,

   104

                            id,

   105

                            specific_values.execution_order)

   106

    return variableCreationFunction

   107

   108

   109

def GetConnectorCreationFunction(connector_type):

   110

    def connectorCreationFunction(viewer, id, specific_values):

   111

        return FBD_Connector(viewer,

   112

                             connector_type,

   113

                             specific_values.name,

   114

                             id)

   115

    return connectorCreationFunction

   116

   117

   118

def commentCreationFunction(viewer, id, specific_values):

   119

    return Comment(viewer, specific_values.content, id)

   120

   121

   122

def GetPowerRailCreationFunction(powerrail_type):

   123

    def powerRailCreationFunction(viewer, id, specific_values):

   124

        return LD_PowerRail(viewer,

   125

                            powerrail_type,

   126

                            id,

   127

                            specific_values.connectors)

   128

    return powerRailCreationFunction

   129

   130

   131

def NEGATED_VALUE(x):

   132

    return x if x is not None else False

   133

   134

   135

def MODIFIER_VALUE(x):

   136

    return x if x is not None else 'none'

   137

   138

   139

CONTACT_TYPES = {(True, "none"): CONTACT_REVERSE,

   140

                 (False, "rising"): CONTACT_RISING,

   141

                 (False, "falling"): CONTACT_FALLING}

   142

   143

   144

def contactCreationFunction(viewer, id, specific_values):

   145

    contact_type = CONTACT_TYPES.get((NEGATED_VALUE(specific_values.negated),

   146

                                      MODIFIER_VALUE(specific_values.edge)),

   147

                                     CONTACT_NORMAL)

   148

    return LD_Contact(viewer, contact_type, specific_values.name, id)

   149

   150

   151

COIL_TYPES = {(True, "none", "none"): COIL_REVERSE,

   152

              (False, "none", "set"): COIL_SET,

   153

              (False, "none", "reset"): COIL_RESET,

   154

              (False, "rising", "none"): COIL_RISING,

   155

              (False, "falling", "none"): COIL_FALLING}

   156

   157

   158

def coilCreationFunction(viewer, id, specific_values):

   159

    coil_type = COIL_TYPES.get((NEGATED_VALUE(specific_values.negated),

   160

                                MODIFIER_VALUE(specific_values.edge),

   161

                                MODIFIER_VALUE(specific_values.storage)),

   162

                               COIL_NORMAL)

   163

    return LD_Coil(viewer, coil_type, specific_values.name, id)

   164

   165

   166

def stepCreationFunction(viewer, id, specific_values):

   167

    step = SFC_Step(viewer,

   168

                    specific_values.name,

   169

                    specific_values.initial,

   170

                    id)

   171

    if specific_values.action is not None:

   172

        step.AddAction()

   173

        connector = step.GetActionConnector()

   174

        connector.SetPosition(wx.Point(*specific_values.action.position))

   175

    return step

   176

   177

   178

def transitionCreationFunction(viewer, id, specific_values):

   179

    transition = SFC_Transition(viewer,

   180

                                specific_values.condition_type,

   181

                                specific_values.condition,

   182

                                specific_values.priority,

   183

                                id)

   184

    return transition

   185

   186

   187

divergence_types = [SELECTION_DIVERGENCE,

   188

                    SELECTION_CONVERGENCE, SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]

   189

   190

   191

def GetDivergenceCreationFunction(divergence_type):

   192

    def divergenceCreationFunction(viewer, id, specific_values):

   193

        return SFC_Divergence(viewer, divergence_type,

   194

                              specific_values.connectors, id)

   195

    return divergenceCreationFunction

   196

   197

   198

def jumpCreationFunction(viewer, id, specific_values):

   199

    return SFC_Jump(viewer, specific_values.target, id)

   200

   201

   202

def actionBlockCreationFunction(viewer, id, specific_values):

   203

    return SFC_ActionBlock(viewer, specific_values.actions, id)

   204

   205

   206

ElementCreationFunctions = {

   207

    "input": GetVariableCreationFunction(INPUT),

   208

    "output": GetVariableCreationFunction(OUTPUT),

   209

    "inout": GetVariableCreationFunction(INOUT),

   210

    "connector": GetConnectorCreationFunction(CONNECTOR),

   211

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   212

    "comment": commentCreationFunction,

   213

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   214

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   215

    "contact": contactCreationFunction,

   216

    "coil": coilCreationFunction,

   217

    "step": stepCreationFunction,

   218

    "transition": transitionCreationFunction,

   219

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE),

   220

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE),

   221

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE),

   222

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE),

   223

    "jump": jumpCreationFunction,

   224

    "actionBlock": actionBlockCreationFunction,

   225

}

   226

   227

   228

def sort_blocks(block_infos1, block_infos2):

   229

    x1, y1 = block_infos1[0].GetPosition()

   230

    x2, y2 = block_infos2[0].GetPosition()

   231

    if y1 == y2:

   232

        return cmp(x1, x2)

   233

    else:

   234

        return cmp(y1, y2)

   235

   236

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

   237

#                       Graphic elements Viewer base class

   238

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

   239

   240

   241

# ID Constants for alignment menu items

   242

[

   243

    ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

   244

    ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

   245

    ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

   246

] = [wx.NewId() for _init_coll_AlignmentMenu_Items in range(6)]

   247

   248

# ID Constants for contextual menu items

   249

[

   250

    ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

   251

    ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

   252

    ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

   253

    ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

   254

    ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

   255

    ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

   256

    ID_VIEWERCONTEXTUALMENUITEMS17,

   257

] = [wx.NewId() for _init_coll_ContextualMenu_Items in range(13)]

   258

   259

   260

class ViewerDropTarget(wx.TextDropTarget):

   261

   262

    def __init__(self, parent):

   263

        wx.TextDropTarget.__init__(self)

   264

        self.ParentWindow = parent

   265

   266

    def OnDropText(self, x, y, data):

   267

        self.ParentWindow.Select()

   268

        tagname = self.ParentWindow.GetTagName()

   269

        pou_name, pou_type = self.ParentWindow.Controler.GetEditedElementType(tagname, self.ParentWindow.Debug)

   270

        x, y = self.ParentWindow.CalcUnscrolledPosition(x, y)

   271

        x = int(x / self.ParentWindow.ViewScale[0])

   272

        y = int(y / self.ParentWindow.ViewScale[1])

   273

        scaling = self.ParentWindow.Scaling

   274

        message = None

   275

        try:

   276

            values = eval(data)

   277

        except Exception:

   278

            message = _("Invalid value \"%s\" for viewer block") % data

   279

            values = None

   280

        if not isinstance(values, TupleType):

   281

            message = _("Invalid value \"%s\" for viewer block") % data

   282

            values = None

   283

        if values is not None:

   284

            if values[1] == "debug":

   285

                pass

   286

            elif values[1] == "program":

   287

                message = _("Programs can't be used by other POUs!")

   288

            elif values[1] in ["function", "functionBlock"]:

   289

                if pou_name == values[0]:

   290

                    message = _("\"%s\" can't use itself!") % pou_name

   291

                elif pou_type == "function" and values[1] != "function":

   292

                    message = _("Function Blocks can't be used in Functions!")

   293

                elif self.ParentWindow.Controler.PouIsUsedBy(pou_name, values[0], self.ParentWindow.Debug):

   294

                    message = _("\"{a1}\" is already used by \"{a2}\"!").format(a1=pou_name, a2=values[0])

   295

                else:

   296

                    blockname = values[2]

   297

                    if len(values) > 3:

   298

                        blockinputs = values[3]

   299

                    else:

   300

                        blockinputs = None

   301

                    if values[1] != "function" and blockname == "":

   302

                        blockname = self.ParentWindow.GenerateNewName(blocktype=values[0])

   303

                    if blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   304

                        message = _("\"%s\" pou already exists!") % blockname

   305

                    elif blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   306

                        message = _("\"%s\" element for this pou already exists!") % blockname

   307

                    else:

   308

                        id = self.ParentWindow.GetNewId()

   309

                        block = FBD_Block(self.ParentWindow, values[0], blockname, id, inputs=blockinputs)

   310

                        width, height = block.GetMinSize()

   311

                        if scaling is not None:

   316

                        block.SetPosition(x, y)

   317

                        block.SetSize(width, height)

   318

                        self.ParentWindow.AddBlock(block)

   319

                        self.ParentWindow.Controler.AddEditedElementBlock(tagname, id, values[0], blockname)

   320

                        self.ParentWindow.RefreshBlockModel(block)

   321

                        self.ParentWindow.RefreshBuffer()

   322

                        self.ParentWindow.RefreshScrollBars()

   323

                        self.ParentWindow.RefreshVisibleElements()

   324

                        self.ParentWindow.RefreshVariablePanel()

   325

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   326

                        self.ParentWindow.Refresh(False)

   327

            elif values[1] == "location":

   328

                if pou_type == "program":

   329

                    location = values[0]

   330

                    if not location.startswith("%"):

   331

                        dialog = wx.SingleChoiceDialog(

   332

                            self.ParentWindow.ParentWindow,

   333

                            _("Select a variable class:"),

   334

                            _("Variable class"),

   335

                            [_("Input"), _("Output"), _("Memory")],

   336

                            wx.DEFAULT_DIALOG_STYLE | wx.OK | wx.CANCEL)

   337

                        if dialog.ShowModal() == wx.ID_OK:

   338

                            selected = dialog.GetSelection()

   339

                        else:

   340

                            selected = None

   341

                        dialog.Destroy()

   342

                        if selected is None:

   343

                            return

   344

                        if selected == 0:

   345

                            location = "%I" + location

   346

                        elif selected == 1:

   347

                            location = "%Q" + location

   348

                        else:

   349

                            location = "%M" + location

   350

                    var_name = values[3]

   351

                    dlg = wx.TextEntryDialog(

   352

                        self.ParentWindow.ParentWindow,

   353

                        _("Confirm or change variable name"),

   354

                        _('Variable Drop'), var_name)

   355

                    dlg.SetValue(var_name)

   356

                    var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   357

                    dlg.Destroy()

   358

                    if var_name is None:

   359

                        return

   360

                    elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   361

                        message = _("\"%s\" pou already exists!") % var_name

   362

                    elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   363

                        if location[1] == "Q":

   364

                            var_class = OUTPUT

   365

                        else:

   366

                            var_class = INPUT

   367

                        if values[2] is not None:

   368

                            var_type = values[2]

   369

                        else:

   370

                            var_type = LOCATIONDATATYPES.get(location[2], ["BOOL"])[0]

   371

                        self.ParentWindow.Controler.AddEditedElementPouVar(tagname, var_type, var_name, location=location, description=values[4])

   372

                        self.ParentWindow.RefreshVariablePanel()

   373

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   374

                        self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   375

                    else:

   376

                        message = _("\"%s\" element for this pou already exists!") % var_name

   377

            elif values[1] == "NamedConstant":

   378

                if pou_type == "program":

   379

                    initval = values[0]

   380

                    var_name = values[3]

   381

                    dlg = wx.TextEntryDialog(

   382

                        self.ParentWindow.ParentWindow,

   383

                        _("Confirm or change variable name"),

   384

                        _('Variable Drop'), var_name)

   385

                    dlg.SetValue(var_name)

   386

                    var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   387

                    dlg.Destroy()

   388

                    if var_name is None:

   389

                        return

   390

                    elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   391

                        message = _("\"%s\" pou already exists!") % var_name

   392

                    elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   393

                        var_class = INPUT

   394

                        var_type = values[2]

   395

                        self.ParentWindow.Controler.AddEditedElementPouVar(tagname, var_type, var_name, description=values[4], initval=initval)

   396

                        self.ParentWindow.RefreshVariablePanel()

   397

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   398

                        self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   399

                    else:

   400

                        message = _("\"%s\" element for this pou already exists!") % var_name

   401

            elif values[1] == "Global":

   402

                var_name = values[0]

   403

                dlg = wx.TextEntryDialog(

   404

                    self.ParentWindow.ParentWindow,

   405

                    _("Confirm or change variable name"),

   406

                    _('Variable Drop'), var_name)

   407

                dlg.SetValue(var_name)

   408

                var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   409

                dlg.Destroy()

   410

                if var_name is None:

   411

                    return

   412

                elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   413

                    message = _("\"%s\" pou already exists!") % var_name

   414

                elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   415

                    self.ParentWindow.Controler.AddEditedElementPouExternalVar(tagname, values[2], var_name)

   416

                    self.ParentWindow.RefreshVariablePanel()

   417

                    self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   418

                    self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, var_name, values[2])

   419

                else:

   420

                    message = _("\"%s\" element for this pou already exists!") % var_name

   421

            elif values[1] == "Constant":

   422

                self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, values[0], None)

   423

            elif values[3] == tagname:

   424

                if values[1] == "Output":

   425

                    var_class = OUTPUT

   426

                elif values[1] == "InOut":

   427

                    var_class = INPUT

   428

                else:

   429

                    var_class = INPUT

   430

                tree = dict([(var.Name, var.Tree) for var in self.ParentWindow.Controler.GetEditedElementInterfaceVars(tagname, True, self.ParentWindow.Debug)]).get(values[0], None)

   431

                if tree is not None:

   432

                    if len(tree[0]) > 0:

   433

                        menu = wx.Menu(title='')

   434

                        self.GenerateTreeMenu(x, y, scaling, menu, "", var_class, [(values[0], values[2], tree)])

   435

                        self.ParentWindow.PopupMenuXY(menu)

   436

                    else:

   437

                        self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, values[0], values[2])

   438

                else:

   439

                    message = _("Unknown variable \"%s\" for this POU!") % values[0]

   440

            else:

   441

                message = _("Variable don't belong to this POU!")

   442

        if message is not None:

   443

            wx.CallAfter(self.ShowMessage, message)

   444

   445

    def GenerateTreeMenu(self, x, y, scaling, menu, base_path, var_class, tree):

   446

        for child_name, child_type, (child_tree, child_dimensions) in tree:

   447

            if base_path:

   448

                child_path = "%s.%s" % (base_path, child_name)

   449

            else:

   450

                child_path = child_name

   451

            if len(child_dimensions) > 0:

   452

                child_path += "[%s]" % ",".join([str(dimension[0]) for dimension in child_dimensions])

   453

                child_name += "[]"

   454

            new_id = wx.NewId()

   455

            AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, text=child_name)

   456

            self.ParentWindow.Bind(wx.EVT_MENU, self.GetAddVariableBlockFunction(x, y, scaling, var_class, child_path, child_type), id=new_id)

   457

            if len(child_tree) > 0:

   458

                new_id = wx.NewId()

   459

                child_menu = wx.Menu(title='')

   460

                self.GenerateTreeMenu(x, y, scaling, child_menu, child_path, var_class, child_tree)

   461

                menu.AppendMenu(new_id, "%s." % child_name, child_menu)

   462

   463

    def GetAddVariableBlockFunction(self, x, y, scaling, var_class, var_name, var_type):

   464

        def AddVariableFunction(event):

   465

            self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   466

        return AddVariableFunction

   467

   468

    def ShowMessage(self, message):

   469

        message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK | wx.ICON_ERROR)

   470

        message.ShowModal()

   471

        message.Destroy()

   472

   473

   474

class DebugInstanceName(DebugDataConsumer):

   475

    VALUE_TRANSLATION = None

   476

   477

    def __init__(self, parent):

   478

        DebugDataConsumer.__init__(self)

   479

        self.Parent = parent

   480

        self.ActionLastState = None

   481

        self.ActionState = None

   482

        self.x_offset = 2

   483

        self.y_offset = 2

   484

   485

        if self.VALUE_TRANSLATION is None:

   486

            self.__class__.VALUE_TRANSLATION = {True: _("Active"), False: _("Inactive")}

   487

   488

    def SetValue(self, value):

   489

        self.ActionState = value

   490

        if self.ActionState != self.ActionLastState:

   491

            self.ActionLastState = self.ActionState

   492

            wx.CallAfter(self.Parent.ElementNeedRefresh, self)

   493

   494

    def GetInstanceName(self):

   495

        return _("Debug: %s") % self.Parent.InstancePath

   496

   497

    def GetRedrawRect(self):

   498

        x, y = self.Parent.CalcUnscrolledPosition(self.x_offset, self.y_offset)

   499

        dc = self.Parent.GetLogicalDC()