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

import re

    26

import math

    27

from time import time as gettime

    28

from types import TupleType

    29

from threading import Lock

    30

    31

import wx

    32

    33

from plcopen.structures import *

    34

from PLCControler import ITEM_VAR_LOCAL, ITEM_POU, ITEM_PROGRAM, ITEM_FUNCTIONBLOCK

    35

from graphics.DebugDataConsumer import DebugDataConsumer

    36

    37

from dialogs import *

    38

from graphics import *

    39

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    40

from EditorPanel import EditorPanel

    41

    42

SCROLLBAR_UNIT = 10

    43

WINDOW_BORDER = 10

    44

SCROLL_ZONE = 10

    45

    46

CURSORS = None

    47

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

    48

    49

    50

def ResetCursors():

    51

    global CURSORS

    52

    if CURSORS is None:

    53

        CURSORS = [wx.NullCursor,

    54

                   wx.StockCursor(wx.CURSOR_HAND),

    55

                   wx.StockCursor(wx.CURSOR_SIZENWSE),

    56

                   wx.StockCursor(wx.CURSOR_SIZENESW),

    57

                   wx.StockCursor(wx.CURSOR_SIZEWE),

    58

                   wx.StockCursor(wx.CURSOR_SIZENS)]

    59

    60

    61

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

    62

    if wx.VERSION >= (2, 6, 0):

    63

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

    64

    else:

    65

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

    66

    67

    68

if wx.Platform == '__WXMSW__':

    69

    faces = {

    70

        'times': 'Times New Roman',

    71

        'mono':  'Courier New',

    72

        'helv':  'Arial',

    73

        'other': 'Comic Sans MS',

    74

        'size':  10,

    75

    }

    76

else:

    77

    faces = {

    78

        'times': 'Times',

    79

        'mono':  'Courier',

    80

        'helv':  'Helvetica',

    81

        'other': 'new century schoolbook',

    82

        'size':  12,

    83

    }

    84

    85

if wx.Platform == '__WXMSW__':

    86

    MAX_ZOOMIN = 4

    87

else:

    88

    MAX_ZOOMIN = 7

    89

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

    90

    91

    92

def GetVariableCreationFunction(variable_type):

    93

    def variableCreationFunction(viewer, id, specific_values):

    94

        return FBD_Variable(viewer,

    95

                            variable_type,

    96

                            specific_values.name,

    97

                            specific_values.value_type,

    98

                            id,

    99

                            specific_values.execution_order)

   100

    return variableCreationFunction

   101

   102

   103

def GetConnectorCreationFunction(connector_type):

   104

    def connectorCreationFunction(viewer, id, specific_values):

   105

        return FBD_Connector(viewer,

   106

                             connector_type,

   107

                             specific_values.name,

   108

                             id)

   109

    return connectorCreationFunction

   110

   111

   112

def commentCreationFunction(viewer, id, specific_values):

   113

    return Comment(viewer, specific_values.content, id)

   114

   115

   116

def GetPowerRailCreationFunction(powerrail_type):

   117

    def powerRailCreationFunction(viewer, id, specific_values):

   118

        return LD_PowerRail(viewer,

   119

                            powerrail_type,

   120

                            id,

   121

                            specific_values.connectors)

   122

    return powerRailCreationFunction

   123

   124

   125

def NEGATED_VALUE(x):

   126

    return x if x is not None else False

   127

   128

   129

def MODIFIER_VALUE(x):

   130

    return x if x is not None else 'none'

   131

   132

   133

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

   134

                 (False, "rising"): CONTACT_RISING,

   135

                 (False, "falling"): CONTACT_FALLING}

   136

   137

   138

def contactCreationFunction(viewer, id, specific_values):

   139

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

   140

                                      MODIFIER_VALUE(specific_values.edge)),

   141

                                     CONTACT_NORMAL)

   142

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

   143

   144

   145

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

   146

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

   147

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

   148

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

   149

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

   150

   151

   152

def coilCreationFunction(viewer, id, specific_values):

   153

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

   154

                                MODIFIER_VALUE(specific_values.edge),

   155

                                MODIFIER_VALUE(specific_values.storage)),

   156

                               COIL_NORMAL)

   157

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

   158

   159

   160

def stepCreationFunction(viewer, id, specific_values):

   161

    step = SFC_Step(viewer,

   162

                    specific_values.name,

   163

                    specific_values.initial,

   164

                    id)

   165

    if specific_values.action is not None:

   166

        step.AddAction()

   167

        connector = step.GetActionConnector()

   168

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

   169

    return step

   170

   171

   172

def transitionCreationFunction(viewer, id, specific_values):

   173

    transition = SFC_Transition(viewer,

   174

                                specific_values.condition_type,

   175

                                specific_values.condition,

   176

                                specific_values.priority,

   177

                                id)

   178

    return transition

   179

   180

   181

divergence_types = [SELECTION_DIVERGENCE,

   182

                    SELECTION_CONVERGENCE, SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]

   183

   184

   185

def GetDivergenceCreationFunction(divergence_type):

   186

    def divergenceCreationFunction(viewer, id, specific_values):

   187

        return SFC_Divergence(viewer, divergence_type,

   188

                              specific_values.connectors, id)

   189

    return divergenceCreationFunction

   190

   191

   192

def jumpCreationFunction(viewer, id, specific_values):

   193

    return SFC_Jump(viewer, specific_values.target, id)

   194

   195

   196

def actionBlockCreationFunction(viewer, id, specific_values):

   197

    return SFC_ActionBlock(viewer, specific_values.actions, id)

   198

   199

   200

ElementCreationFunctions = {

   201

    "input": GetVariableCreationFunction(INPUT),

   202

    "output": GetVariableCreationFunction(OUTPUT),

   203

    "inout": GetVariableCreationFunction(INOUT),

   204

    "connector": GetConnectorCreationFunction(CONNECTOR),

   205

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   206

    "comment": commentCreationFunction,

   207

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   208

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   209

    "contact": contactCreationFunction,

   210

    "coil": coilCreationFunction,

   211

    "step": stepCreationFunction,

   212

    "transition": transitionCreationFunction,

   213

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE),

   214

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE),

   215

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE),

   216

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE),

   217

    "jump": jumpCreationFunction,

   218

    "actionBlock": actionBlockCreationFunction,

   219

}

   220

   221

   222

def sort_blocks(block_infos1, block_infos2):

   223

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

   224

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

   225

    if y1 == y2:

   226

        return cmp(x1, x2)

   227

    else:

   228

        return cmp(y1, y2)

   229

   231

#                       Graphic elements Viewer base class

   233

   234

   235

# ID Constants for alignment menu items

   236

[

   237

    ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

   238

    ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

   239

    ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

   240

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

   241

   242

# ID Constants for contextual menu items

   243

[

   244

    ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

   245

    ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

   246

    ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

   247

    ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

   248

    ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

   249

    ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

   250

    ID_VIEWERCONTEXTUALMENUITEMS17,

   251

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

   252

   253

   254

class ViewerDropTarget(wx.TextDropTarget):

   255

   256

    def __init__(self, parent):

   257

        wx.TextDropTarget.__init__(self)

   258

        self.ParentWindow = parent

   259

   260

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

   261

        self.ParentWindow.Select()

   262

        tagname = self.ParentWindow.GetTagName()

   263

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

   264

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

   265

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

   266

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

   267

        scaling = self.ParentWindow.Scaling

   268

        message = None

   269

        try:

   270

            values = eval(data)

   271

        except Exception:

   272

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

   273

            values = None

   274

        if not isinstance(values, TupleType):

   275

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

   276

            values = None

   277

        if values is not None:

   278

            if values[1] == "debug":

   279

                pass

   280

            elif values[1] == "program":

   281

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

   282

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

   283

                words = tagname.split("::")

   284

                if pou_name == values[0]:

   285

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

   286

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

   287

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

   288

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

   289

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

   290

                else:

   291

                    blockname = values[2]

   292

                    if len(values) > 3:

   293

                        blockinputs = values[3]

   294

                    else:

   295

                        blockinputs = None

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

                    else:

   303

                        id = self.ParentWindow.GetNewId()

   304

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

   305

                        width, height = block.GetMinSize()

   306

                        if scaling is not None:

   307

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

   308

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

   309

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

   310

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

   311

                        block.SetPosition(x, y)

   312

                        block.SetSize(width, height)

   313

                        self.ParentWindow.AddBlock(block)

   314

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

   315

                        self.ParentWindow.RefreshBlockModel(block)

   316

                        self.ParentWindow.RefreshBuffer()

   317

                        self.ParentWindow.RefreshScrollBars()

   318

                        self.ParentWindow.RefreshVisibleElements()

   319

                        self.ParentWindow.RefreshVariablePanel()

   320

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   321

                        self.ParentWindow.Refresh(False)

   322

            elif values[1] == "location":

   323

                if pou_type == "program":

   324

                    location = values[0]

   325

                    if not location.startswith("%"):

   326

                        dialog = wx.SingleChoiceDialog(

   327

                            self.ParentWindow.ParentWindow,

   328

                            _("Select a variable class:"),

   329

                            _("Variable class"),

   330

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

   331

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

   332

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

   333

                            selected = dialog.GetSelection()

   334

                        else:

   335

                            selected = None

   336

                        dialog.Destroy()

   337

                        if selected is None:

   338

                            return

   339

                        if selected == 0:

   340

                            location = "%I" + location

   341

                        elif selected == 1:

   342

                            location = "%Q" + location

   343

                        else:

   344

                            location = "%M" + location

   345

                    var_name = values[3]

   346

                    dlg = wx.TextEntryDialog(

   347

                        self.ParentWindow.ParentWindow,

   348

                        _("Confirm or change variable name"),

   349

                        _('Variable Drop'), var_name)

   350

                    dlg.SetValue(var_name)

   351

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

   352

                    dlg.Destroy()

   353

                    if var_name is None:

   354

                        return

   355

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

   356

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

   357

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

   358

                        if location[1] == "Q":

   359

                            var_class = OUTPUT

   360

                        else:

   361

                            var_class = INPUT

   362

                        if values[2] is not None:

   363

                            var_type = values[2]

   364

                        else:

   365

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

   366

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

   367

                        self.ParentWindow.RefreshVariablePanel()

   368

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   369

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

   370

                    else:

   371

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

   372

            elif values[1] == "NamedConstant":

   373

                if pou_type == "program":

   374

                    initval = values[0]

   375

                    var_name = values[3]

   376

                    dlg = wx.TextEntryDialog(

   377

                        self.ParentWindow.ParentWindow,

   378

                        _("Confirm or change variable name"),

   379

                        _('Variable Drop'), var_name)

   380

                    dlg.SetValue(var_name)

   381

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

   382

                    dlg.Destroy()

   383

                    if var_name is None:

   384

                        return

   385

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

   386

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

   387

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

   388

                        var_class = INPUT

   389

                        var_type = values[2]

   390

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

   391

                        self.ParentWindow.RefreshVariablePanel()

   392

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   393

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

   394

                    else:

   395

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

   396

            elif values[1] == "Global":

   397

                var_name = values[0]

   398

                dlg = wx.TextEntryDialog(

   399

                    self.ParentWindow.ParentWindow,

   400

                    _("Confirm or change variable name"),

   401

                    _('Variable Drop'), var_name)

   402

                dlg.SetValue(var_name)

   403

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

   404

                dlg.Destroy()

   405

                if var_name is None:

   406

                    return

   407

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

   408

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

   409

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

   410

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

   411

                    self.ParentWindow.RefreshVariablePanel()

   412

                    self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   413

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

   414

                else:

   415

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

   416

            elif values[1] == "Constant":

   417

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

   418

            elif values[3] == tagname:

   419

                if values[1] == "Output":

   420

                    var_class = OUTPUT

   421

                elif values[1] == "InOut":

   422

                    var_class = INPUT

   423

                else:

   424

                    var_class = INPUT

   425

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

   426

                if tree is not None:

   427

                    if len(tree[0]) > 0:

   428

                        menu = wx.Menu(title='')

   429

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

   430

                        self.ParentWindow.PopupMenuXY(menu)

   431

                    else:

   432

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

   433

                else:

   434

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

   435

            else:

   436

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

   437

        if message is not None:

   438

            wx.CallAfter(self.ShowMessage, message)

   439

   440

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

   441

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

   442

            if base_path:

   443

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

   444

            else:

   445

                child_path = child_name

   446

            if len(child_dimensions) > 0:

   447

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

   448

                child_name += "[]"

   449

            new_id = wx.NewId()

   450

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

   451

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

   452

            if len(child_tree) > 0:

   453

                new_id = wx.NewId()

   454

                child_menu = wx.Menu(title='')

   455

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

   456

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

   457

   458

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

   459

        def AddVariableFunction(event):

   460

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

   461

        return AddVariableFunction

   462

   463

    def ShowMessage(self, message):

   464

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

   465

        message.ShowModal()

   466

        message.Destroy()

   467

   468

   469

class DebugInstanceName(DebugDataConsumer):

   470

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

   471

   472

    def __init__(self, parent):

   473

        DebugDataConsumer.__init__(self)

   474

        self.Parent = parent

   475

        self.ActionLastState = None

   476

        self.ActionState = None

   477

        self.x_offset = 2

   478

        self.y_offset = 2

   479

   480

    def SetValue(self, value):

   481

        self.ActionState = value

   482

        if self.ActionState != self.ActionLastState:

   483

            self.ActionLastState = self.ActionState

   484

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

   485

   486

    def GetInstanceName(self):

   487

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

   488

   489

    def GetRedrawRect(self):

   490

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

   491

        dc = self.Parent.GetLogicalDC()

   492

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

   493

        vw, vh = 0, 0

   494

        for value in self.VALUE_TRANSLATION.itervalues():

   495

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

   496

            vw = max(vw, w)

   497

            vh = max(vh, h)

   498

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

   499

   500

    def Draw(self, dc):

   501

        scalex, scaley = dc.GetUserScale()