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

    27

from __future__ import division

    28

import math

    29

from time import time as gettime

    30

from threading import Lock

    31

from future.builtins import round

    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.Cursor(wx.CURSOR_HAND),

    64

                   wx.Cursor(wx.CURSOR_SIZENWSE),

    65

                   wx.Cursor(wx.CURSOR_SIZENESW),

    66

                   wx.Cursor(wx.CURSOR_SIZEWE),

    67

                   wx.Cursor(wx.CURSOR_SIZENS)]

    68

    69

    70

if wx.Platform == '__WXMSW__':

    71

    faces = {

    72

        'times': 'Times New Roman',

    73

        'mono':  'Courier New',

    74

        'helv':  'Arial',

    75

        'other': 'Comic Sans MS',

    76

        'size':  10,

    77

    }

    78

else:

    79

    faces = {

    80

        'times': 'Times',

    81

        'mono':  'FreeMono',

    82

        'helv':  'Helvetica',

    83

        'other': 'new century schoolbook',

    84

        'size':  10,

    85

    }

    86

    87

if wx.Platform == '__WXMSW__':

    88

    MAX_ZOOMIN = 4

    89

else:

    90

    MAX_ZOOMIN = 7

    91

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

    92

    93

    94

def GetVariableCreationFunction(variable_type):

    95

    def variableCreationFunction(viewer, id, specific_values):

    96

        return FBD_Variable(viewer,

    97

                            variable_type,

    98

                            specific_values.name,

    99

                            specific_values.value_type,

   100

                            id,

   101

                            specific_values.execution_order)

   102

    return variableCreationFunction

   103

   104

   105

def GetConnectorCreationFunction(connector_type):

   106

    def connectorCreationFunction(viewer, id, specific_values):

   107

        return FBD_Connector(viewer,

   108

                             connector_type,

   109

                             specific_values.name,

   110

                             id)

   111

    return connectorCreationFunction

   112

   113

   114

def commentCreationFunction(viewer, id, specific_values):

   115

    return Comment(viewer, specific_values.content, id)

   116

   117

   118

def GetPowerRailCreationFunction(powerrail_type):

   119

    def powerRailCreationFunction(viewer, id, specific_values):

   120

        return LD_PowerRail(viewer,

   121

                            powerrail_type,

   122

                            id,

   123

                            specific_values.connectors)

   124

    return powerRailCreationFunction

   125

   126

   127

def NEGATED_VALUE(x):

   128

    return x if x is not None else False

   129

   130

   131

def MODIFIER_VALUE(x):

   132

    return x if x is not None else 'none'

   133

   134

   135

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

   136

                 (False, "rising"): CONTACT_RISING,

   137

                 (False, "falling"): CONTACT_FALLING}

   138

   139

   140

def contactCreationFunction(viewer, id, specific_values):

   141

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

   142

                                      MODIFIER_VALUE(specific_values.edge)),

   143

                                     CONTACT_NORMAL)

   144

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

   145

   146

   147

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

   148

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

   149

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

   150

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

   151

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

   152

   153

   154

def coilCreationFunction(viewer, id, specific_values):

   155

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

   156

                                MODIFIER_VALUE(specific_values.edge),

   157

                                MODIFIER_VALUE(specific_values.storage)),

   158

                               COIL_NORMAL)

   159

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

   160

   161

   162

def stepCreationFunction(viewer, id, specific_values):

   163

    step = SFC_Step(viewer,

   164

                    specific_values.name,

   165

                    specific_values.initial,

   166

                    id)

   167

    if specific_values.action is not None:

   168

        step.AddAction()

   169

        connector = step.GetActionConnector()

   170

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

   171

    return step

   172

   173

   174

def transitionCreationFunction(viewer, id, specific_values):

   175

    transition = SFC_Transition(viewer,

   176

                                specific_values.condition_type,

   177

                                specific_values.condition,

   178

                                specific_values.priority,

   179

                                id)

   180

    return transition

   181

   182

   183

divergence_types = [SELECTION_DIVERGENCE,

   184

                    SELECTION_CONVERGENCE, SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]

   185

   186

   187

def GetDivergenceCreationFunction(divergence_type):

   188

    def divergenceCreationFunction(viewer, id, specific_values):

   189

        return SFC_Divergence(viewer, divergence_type,

   190

                              specific_values.connectors, id)

   191

    return divergenceCreationFunction

   192

   193

   194

def jumpCreationFunction(viewer, id, specific_values):

   195

    return SFC_Jump(viewer, specific_values.target, id)

   196

   197

   198

def actionBlockCreationFunction(viewer, id, specific_values):

   199

    return SFC_ActionBlock(viewer, specific_values.actions, id)

   200

   201

   202

ElementCreationFunctions = {

   203

    "input": GetVariableCreationFunction(INPUT),

   204

    "output": GetVariableCreationFunction(OUTPUT),

   205

    "inout": GetVariableCreationFunction(INOUT),

   206

    "connector": GetConnectorCreationFunction(CONNECTOR),

   207

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   208

    "comment": commentCreationFunction,

   209

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   210

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   211

    "contact": contactCreationFunction,

   212

    "coil": coilCreationFunction,

   213

    "step": stepCreationFunction,

   214

    "transition": transitionCreationFunction,

   215

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE),

   216

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE),

   217

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE),

   218

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE),

   219

    "jump": jumpCreationFunction,

   220

    "actionBlock": actionBlockCreationFunction,

   221

}

   222

   223

   224

def sort_blocks(block_infos1, block_infos2):

   225

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

   226

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

   227

    if y1 == y2:

   228

        return cmp(x1, x2)

   229

    else:

   230

        return cmp(y1, y2)

   231

   232

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

   233

#                       Graphic elements Viewer base class

   234

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

   235

   236

   237

class ViewerDropTarget(wx.TextDropTarget):

   238

   239

    def __init__(self, parent):

   240

        wx.TextDropTarget.__init__(self)

   241

        self.ParentWindow = parent

   242

   243

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

   244

        self.ParentWindow.Select()

   245

        tagname = self.ParentWindow.GetTagName()

   246

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

   247

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

   248

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

   249

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

   250

        scaling = self.ParentWindow.Scaling

   251

        message = None

   252

        try:

   253

            values = eval(data)

   254

        except Exception:

   255

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

   256

            values = None

   257

        if not isinstance(values, tuple):

   258

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

   259

            values = None

   260

        if values is not None:

   261

            if values[1] == "debug":

   262

                pass

   263

            elif values[1] == "program":

   264

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

   265

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

   266

                if pou_name == values[0]:

   267

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

   268

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

   269

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

   270

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

   271

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

   272

                else:

   273

                    blockname = values[2]

   274

                    if len(values) > 3:

   275

                        blockinputs = values[3]

   276

                    else:

   277

                        blockinputs = None

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

                    else:

   285

                        id = self.ParentWindow.GetNewId()

   286

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

   287

                        width, height = block.GetMinSize()

   288

                        if scaling is not None:

   289

                            x = round(x / scaling[0]) * scaling[0]

   290

                            y = round(y / scaling[1]) * scaling[1]

   291

                            width = round(width / scaling[0] + 0.5) * scaling[0]

   292

                            height = round(height / scaling[1] + 0.5) * scaling[1]

   293

                        block.SetPosition(x, y)

   294

                        block.SetSize(width, height)

   295

                        self.ParentWindow.AddBlock(block)

   296

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

   297

                        self.ParentWindow.RefreshBlockModel(block)

   298

                        self.ParentWindow.RefreshBuffer()

   299

                        self.ParentWindow.RefreshScrollBars()

   300

                        self.ParentWindow.RefreshVisibleElements()

   301

                        self.ParentWindow.RefreshVariablePanel()

   302

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   303

                        self.ParentWindow.Refresh(False)

   304

            elif values[1] == "location":

   305

                if pou_type == "program":

   306

                    location = values[0]

   307

                    if not location.startswith("%"):

   308

                        dialog = wx.SingleChoiceDialog(

   309

                            self.ParentWindow.ParentWindow,

   310

                            _("Select a variable class:"),

   311

                            _("Variable class"),

   312

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

   313

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

   314

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

   315

                            selected = dialog.GetSelection()

   316

                        else:

   317

                            selected = None

   318

                        dialog.Destroy()

   319

                        if selected is None:

   320

                            return

   321

                        if selected == 0:

   322

                            location = "%I" + location

   323

                        elif selected == 1:

   324

                            location = "%Q" + location

   325

                        else:

   326

                            location = "%M" + location

   327

                    var_name = values[3]

   328

                    dlg = wx.TextEntryDialog(

   329

                        self.ParentWindow.ParentWindow,

   330

                        _("Confirm or change variable name"),

   331

                        _('Variable Drop'), var_name)

   332

                    dlg.SetValue(var_name)

   333

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

   334

                    dlg.Destroy()

   335

                    if var_name is None:

   336

                        return

   337

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

   338

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

   339

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

   340

                        if location[1] == "Q":

   341

                            var_class = OUTPUT

   342

                        else:

   343

                            var_class = INPUT

   344

                        if values[2] is not None:

   345

                            var_type = values[2]

   346

                        else:

   347

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

   348

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

   349

                        self.ParentWindow.RefreshVariablePanel()

   350

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   351

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

   352

                    else:

   353

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

   354

            elif values[1] == "NamedConstant":

   355

                if pou_type == "program":

   356

                    initval = values[0]

   357

                    var_name = values[3]

   358

                    dlg = wx.TextEntryDialog(

   359

                        self.ParentWindow.ParentWindow,

   360

                        _("Confirm or change variable name"),

   361

                        _('Variable Drop'), var_name)

   362

                    dlg.SetValue(var_name)

   363

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

   364

                    dlg.Destroy()

   365

                    if var_name is None:

   366

                        return

   367

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

   368

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

   369

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

   370

                        var_class = INPUT

   371

                        var_type = values[2]

   372

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

   373

                        self.ParentWindow.RefreshVariablePanel()

   374

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   375

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

   376

                    else:

   377

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

   378

            elif values[1] == "Global":

   379

                var_name = values[0]

   380

                dlg = wx.TextEntryDialog(

   381

                    self.ParentWindow.ParentWindow,

   382

                    _("Confirm or change variable name"),

   383

                    _('Variable Drop'), var_name)

   384

                dlg.SetValue(var_name)

   385

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

   386

                dlg.Destroy()

   387

                if var_name is None:

   388

                    return

   389

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

   390

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

   391

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

   392

                    kwargs = dict(description=values[4]) if len(values)>4 else {}

   393

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

   394

                    self.ParentWindow.RefreshVariablePanel()

   395

                    self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   396

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

   397

                else:

   398

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

   399

            elif values[1] == "Constant":

   400

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

   401

            elif values[3] == tagname:

   402

                if values[1] == "Output":

   403

                    var_class = OUTPUT

   404

                elif values[1] == "InOut":

   405

                    var_class = INPUT

   406

                else:

   407

                    var_class = INPUT

   408

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

   409

                if tree is not None:

   410

                    if len(tree[0]) > 0:

   411

                        menu = wx.Menu(title='')

   412

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

   413

                        self.ParentWindow.PopupMenu(menu)

   414

                    else:

   415

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

   416

                else:

   417

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

   418

            else:

   419

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

   420

        if message is not None:

   421

            wx.CallAfter(self.ShowMessage, message)

   422

   423

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

   424

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

   425

            if base_path:

   426

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

   427

            else:

   428

                child_path = child_name

   429

            if len(child_dimensions) > 0:

   430

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

   431

                child_name += "[]"

   432

            item = menu.Append(wx.ID_ANY, help='', kind=wx.ITEM_NORMAL, text=child_name)

   433

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

   434

            if len(child_tree) > 0:

   435

                child_menu = wx.Menu(title='')

   436

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

   437

                menu.AppendMenu(wx.ID_ANY, "%s." % child_name, child_menu)

   438

   439

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

   440

        def AddVariableFunction(event):

   441

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

   442

        return AddVariableFunction

   443

   444

    def ShowMessage(self, message):

   445

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

   446

        message.ShowModal()

   447

        message.Destroy()

   448

   449

   450

class DebugInstanceName(DebugDataConsumer):

   451

    VALUE_TRANSLATION = None

   452

   453

    def __init__(self, parent):

   454

        DebugDataConsumer.__init__(self)

   455

        self.Parent = parent

   456

        self.ActionLastState = None

   457

        self.ActionState = None

   458

        self.x_offset = 2

   459

        self.y_offset = 2

   460

   461

        if self.VALUE_TRANSLATION is None:

   462

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

   463

   464

    def SetValue(self, value):

   465

        self.ActionState = value

   466

        if self.ActionState != self.ActionLastState:

   467

            self.ActionLastState = self.ActionState

   468

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

   469

   470

    def GetInstanceName(self):

   471

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

   472

   473

    def GetRedrawRect(self):

   474

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

   475

        dc = self.Parent.GetLogicalDC()

   476

        ipw, _iph = dc.GetTextExtent(self.GetInstanceName())

   477

        vw, vh = 0, 0

   478

        for value in self.VALUE_TRANSLATION.itervalues():

   479

            w, h = dc.GetTextExtent(" (%s)" % value)

   480

            vw = max(vw, w)

   481

            vh = max(vh, h)

   482

        return wx.Rect(ipw + x, y, vw, vh)

   483

   484

    def Draw(self, dc):

   485

        scalex, scaley = dc.GetUserScale()

   486

        dc.SetUserScale(1, 1)

   487

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

   488

   489

        text = self.GetInstanceName()

   490

        if self.ActionState is not None:

   491

            text += " ("

   492

   493

        dc.DrawText(text, x, y)

   494

        tw, _th = dc.GetTextExtent(text)

   495

        if self.ActionState is not None:

   496

   497

            text = self.VALUE_TRANSLATION[self.ActionState]