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

import wx

    26

from time import time as gettime

    27

from math import *

    28

from types import *

    29

    30

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

    31

#                               Common constants

    32

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

    33

    34

"""

    35

Definition of constants for dimensions of graphic elements

    36

"""

    37

    38

# FBD and SFC constants

    39

MIN_MOVE = 5                            # Minimum move before starting a element dragging

    40

CONNECTOR_SIZE = 8                      # Size of connectors

    41

BLOCK_LINE_SIZE = 20                    # Minimum size of each line in a block

    42

HANDLE_SIZE = 6                         # Size of the squares for handles

    43

ANCHOR_DISTANCE = 5                     # Distance where wire is automativally attached to a connector

    44

POINT_RADIUS = 2                        # Radius of the point of wire ends

    45

MIN_SEGMENT_SIZE = 2                    # Minimum size of the endling segments of a wire

    46

    47

# LD constants

    48

LD_LINE_SIZE = 40                       # Distance between two lines in a ladder rung

    49

LD_ELEMENT_SIZE = (21, 15)              # Size (width, height) of a ladder element (contact or coil)

    50

LD_WIRE_SIZE = 30                       # Size of a wire between two contact

    51

LD_WIRECOIL_SIZE = 70                   # Size of a wire between a coil and a contact

    52

LD_POWERRAIL_WIDTH = 3                  # Width of a Powerrail

    53

LD_OFFSET = (10, 10)                    # Distance (x, y) between each comment and rung of the ladder

    54

LD_COMMENT_DEFAULTSIZE = (600, 40)      # Size (width, height) of a comment box

    55

    56

# SFC constants

    57

SFC_STEP_DEFAULT_SIZE = (40, 30)        # Default size of a SFC step

    58

SFC_TRANSITION_SIZE = (20, 2)           # Size of a SFC transition

    59

SFC_DEFAULT_SEQUENCE_INTERVAL = 40      # Default size of the interval between two divergence branches

    60

SFC_SIMULTANEOUS_SEQUENCE_EXTRA = 20    # Size of extra lines for simultaneous divergence and convergence

    61

SFC_JUMP_SIZE = (12, 13)                # Size of a SFC jump to step

    62

SFC_WIRE_MIN_SIZE = 25                  # Size of a wire between two elements

    63

SFC_ACTION_MIN_SIZE = (100, 30)         # Minimum size of an action block line

    64

    65

# Type definition constants for graphic elements

    66

[INPUT, OUTPUT, INOUT] = range(3)

    67

[CONNECTOR, CONTINUATION] = range(2)

    68

[LEFTRAIL, RIGHTRAIL] = range(2)

    69

[CONTACT_NORMAL, CONTACT_REVERSE, CONTACT_RISING, CONTACT_FALLING] = range(4)

    70

[COIL_NORMAL, COIL_REVERSE, COIL_SET, COIL_RESET, COIL_RISING, COIL_FALLING] = range(6)

    71

[SELECTION_DIVERGENCE, SELECTION_CONVERGENCE, SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE] = range(4)

    72

    73

# Constants for defining the type of dragging that has been selected

    74

[HANDLE_MOVE, HANDLE_RESIZE, HANDLE_POINT, HANDLE_SEGMENT, HANDLE_CONNECTOR] = range(5)

    75

    76

# List of value for resize handle that are valid

    77

VALID_HANDLES = [(1,1), (1,2), (1,3), (2,3), (3,3), (3,2), (3,1), (2,1)]

    78

    79

# Contants for defining the direction of a connector

    80

[EAST, NORTH, WEST, SOUTH] = [(1,0), (0,-1), (-1,0), (0,1)]

    81

    82

# Contants for defining which mode is selected for each view 

    83

[MODE_SELECTION, MODE_BLOCK, MODE_VARIABLE, MODE_CONNECTION, MODE_COMMENT, 

    84

 MODE_COIL, MODE_CONTACT, MODE_POWERRAIL, MODE_INITIALSTEP, MODE_STEP, 

    85

 MODE_TRANSITION, MODE_DIVERGENCE, MODE_JUMP, MODE_ACTION] = range(14)

    86

    87

# Contants for defining alignment types for graphic group 

    88

[ALIGN_LEFT, ALIGN_CENTER, ALIGN_RIGHT, ALIGN_TOP, ALIGN_MIDDLE, ALIGN_BOTTOM] = range(6)

    89

    90

# Contants for defining which drawing mode is selected for app

    91

[FREEDRAWING_MODE, DRIVENDRAWING_MODE] = [1, 2]

    92

    93

# Color for Highlighting

    94

HIGHLIGHTCOLOR = wx.CYAN

    95

    96

HANDLE_CURSORS = {

    97

    (1, 1) : 2,

    98

    (3, 3) : 2,

    99

    (1, 3) : 3,

   100

    (3, 1) : 3,

   101

    (1, 2) : 4,

   102

    (3, 2) : 4,

   103

    (2, 1) : 5,

   104

    (2, 3) : 5

   105

}

   106

   107

def round_scaling(x, n, constraint=0):

   108

    fraction = float(x) / float(n)

   109

    if constraint == - 1:

   110

        xround = int(fraction)

   111

    else:

   112

        xround = round(fraction)

   113

        if constraint == 1 and int(fraction) == xround:

   114

            xround += 1

   115

    return xround * n

   116

   117

"""

   118

Basic vector operations for calculate wire points

   119

"""

   120

   121

# Create a vector from two points and define if vector must be normal

   122

def vector(p1, p2, normal = True):

   123

    vector = (p2.x - p1.x, p2.y - p1.y)

   124

    if normal:

   125

        return normalize(vector)

   126

    return vector

   127

   128

# Calculate the norm of a given vector

   129

def norm(v):

   130

    return sqrt(v[0] * v[0] + v[1] * v[1])

   131

   132

# Normalize a given vector

   133

def normalize(v):

   134

    v_norm = norm(v)

   135

    # Verifie if it is not a null vector

   136

    if v_norm > 0:

   137

        return (v[0] / v_norm, v[1] / v_norm)

   138

    else:

   139

        return v

   140

   141

# Calculate the scalar product of two vectors

   142

def is_null_vector(v):

   143

    return v == (0, 0)

   144

   145

# Calculate the scalar product of two vectors

   146

def add_vectors(v1, v2):

   147

    return (v1[0] + v2[0], v1[1] + v2[1])

   148

   149

# Calculate the scalar product of two vectors

   150

def product(v1, v2):

   151

    return v1[0] * v2[0] + v1[1] * v2[1]

   152

   153

   154

"""

   155

Function that calculates the nearest point of the grid defined by scaling for the given point

   156

"""

   157

   158

def GetScaledEventPosition(event, dc, scaling):

   159

    pos = event.GetLogicalPosition(dc)

   160

    if scaling:

   161

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

   162

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

   163

    return pos

   164

   165

   166

"""

   167

Function that choose a direction during the wire points generation

   168

"""

   169

   170

def DirectionChoice(v_base, v_target, dir_target):

   171

    dir_product = product(v_base, v_target)

   172

    if dir_product < 0:

   173

        return (-v_base[0], -v_base[1])

   174

    elif dir_product == 0 and product(v_base, dir_target) != 0:

   175

        return dir_target

   176

    return v_base

   177

   178

   179

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

   180

#                            Debug Data Consumer Class

   181

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

   182

   183

class DebugDataConsumer:

   184

   185

    def __init__(self):

   186

        self.LastValue = None

   187

        self.Value = None

   188

        self.LastForced = False

   189

        self.Forced = False

   190

        self.Inhibited = False

   191

   192

    def Inhibit(self, inhibit):

   193

        self.Inhibited = inhibit

   194

        if not inhibit and self.LastValue is not None:

   195

            self.Forced = self.LastForced

   196

            self.SetValue(self.LastValue)

   197

            self.LastValue = None

   198

   199

    def NewValue(self, tick, value, forced=False):

   200

        if self.Inhibited:

   201

            self.LastValue = value

   202

            self.LastForced = forced

   203

        else:

   204

            self.Forced = forced

   205

            self.SetValue(value)

   206

   207

    def SetValue(self, value):

   208

        self.Value = value

   209

   210

    def IsForced(self):

   211

        return self.Forced

   212

   213

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

   214

#                               Debug Viewer Class

   215

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

   216

   217

REFRESH_PERIOD = 0.1

   218

   219

class DebugViewer:

   220

   221

    def __init__(self, producer, debug, register_tick=True):

   222

        self.DataProducer = None

   223

        self.Debug = debug

   224

        self.RegisterTick = register_tick

   225

        self.Inhibited = False

   226

   227

        self.DataConsumers = {}

   228

   229

        self.LastRefreshTime = gettime()

   230

   231

        self.RefreshTimer = wx.Timer(self, -1)

   232

        self.Bind(wx.EVT_TIMER, self.OnRefreshTimer, self.RefreshTimer)

   233

   234

        self.SetDataProducer(producer)

   235

   236

    def __del__(self):

   237

        self.DataProducer = None

   238

        self.DeleteDataConsumers()

   239

        self.RefreshTimer.Stop()

   240

   241

    def SetDataProducer(self, producer):

   242

        if self.RegisterTick and self.Debug:

   243

            if producer is not None:

   244

                producer.SubscribeDebugIECVariable("__tick__", self)

   245

            elif self.DataProducer is not None:

   246

                self.DataProducer.UnsubscribeDebugIECVariable("__tick__", self)        

   247

        self.DataProducer = producer

   248

   249

    def IsDebugging(self):

   250

        return self.Debug

   251

   252

    def Inhibit(self, inhibit):

   253

        self.Inhibited = inhibit

   254

        for consumer, iec_path in self.DataConsumers.iteritems():

   255

            consumer.Inhibit(inhibit)

   256

   257

    def AddDataConsumer(self, iec_path, consumer):

   258

        if self.DataProducer is None:

   259

            return False

   260

        result = self.DataProducer.SubscribeDebugIECVariable(iec_path, consumer) is not None

   261

        if result is not None and consumer != self:

   262

            self.DataConsumers[consumer] = iec_path

   263

        return result

   264

   265

    def RemoveDataConsumer(self, consumer):

   266

        iec_path = self.DataConsumers.pop(consumer, None)

   267

        if iec_path is not None:

   268

            self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   269

   270

    def GetDataType(self, iec_path):

   271

        if self.DataProducer is not None:

   272

            return self.DataProducer.GetDebugIECVariableType(iec_path)

   273

        return None

   274

   275

    def ForceDataValue(self, iec_path, value):

   276

        if self.DataProducer is not None:

   277

            self.DataProducer.ForceDebugIECVariable(iec_path, value)

   278

   279

    def ReleaseDataValue(self, iec_path):

   280

        if self.DataProducer is not None:

   281

            self.DataProducer.ReleaseDebugIECVariable(iec_path)

   282

   283

    def DeleteDataConsumers(self):

   284

        if self.DataProducer is not None:

   285

            for consumer, iec_path in self.DataConsumers.iteritems():

   286

                self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   287

        self.DataConsumers = {}

   288

   289

    def OnRefreshTimer(self, event):

   290

        self.RefreshNewData()

   291

        event.Skip()

   292

   293

    def NewDataAvailable(self):

   294

        self.RefreshTimer.Stop()

   295

        if not self.Inhibited:

   296

            current_time = gettime()

   297

            if current_time - self.LastRefreshTime > REFRESH_PERIOD:

   298

                self.LastRefreshTime = current_time

   299

                self.Inhibit(True)

   300

                wx.CallAfter(self.RefreshViewOnNewData)

   301

   302

    def RefreshViewOnNewData(self):

   303

        if self:

   304

            self.RefreshNewData()

   305

            self.RefreshTimer.Start(int(REFRESH_PERIOD * 1000), oneShot=True)

   306

   307

    def RefreshNewData(self):

   308

        self.Inhibit(False)

   309

   310

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

   311

#                               Viewer Rubberband

   312

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

   313

   314

"""

   315

Class that implements a rubberband

   316

"""

   317

   318

class RubberBand:

   319

   320

    # Create a rubberband by indicated on which window it must be drawn

   321

    def __init__(self, drawingSurface):

   322

        self.drawingSurface = drawingSurface

   323

        self.Reset()

   324

   325

    # Method that initializes the internal attributes of the rubberband

   326

    def Reset(self):

   327

        self.startPoint = None

   328

        self.currentBox = None

   329

        self.lastBox = None

   330

   331

    # Method that return if a box is currently edited

   332

    def IsShown(self):

   333

        return self.currentBox != None

   334

   335

    # Method that returns the currently edited box

   336

    def GetCurrentExtent(self):

   337

        return self.currentBox

   338

   339

    # Method called when a new box starts to be edited

   340

    def OnLeftDown(self, event, dc, scaling):

   341

        pos = GetScaledEventPosition(event, dc, scaling)

   342

        # Save the point for calculate the box position and size

   343

        self.startPoint = pos

   344

        self.currentBox = wx.Rect(pos.x, pos.y, 0, 0)

   345

        self.drawingSurface.SetCursor(wx.StockCursor(wx.CURSOR_CROSS))

   346

        self.Redraw()

   347

   348

    # Method called when dragging with a box edited

   349

    def OnMotion(self, event, dc, scaling):

   350

        pos = GetScaledEventPosition(event, dc, scaling)

   351

        # Save the last position and size of the box for erasing it

   352

        self.lastBox = wx.Rect(self.currentBox.x, self.currentBox.y, self.currentBox.width,

   353

            self.currentBox.height)

   354

        # Calculate new position and size of the box 

   355

        if pos.x >= self.startPoint.x:

   356

            self.currentBox.x = self.startPoint.x

   357

            self.currentBox.width = pos.x - self.startPoint.x + 1

   358

        else:

   359

            self.currentBox.x = pos.x

   360

            self.currentBox.width = self.startPoint.x - pos.x + 1

   361

        if pos.y >= self.startPoint.y:

   362

            self.currentBox.y = self.startPoint.y

   363

            self.currentBox.height = pos.y - self.startPoint.y + 1

   364

        else:

   365

            self.currentBox.y = pos.y

   366

            self.currentBox.height = self.startPoint.y - pos.y + 1

   367

        self.Redraw()

   368

   369

    # Method called when dragging is stopped

   370

    def OnLeftUp(self, event, dc, scaling):

   371

        self.drawingSurface.SetCursor(wx.NullCursor)

   372

        self.lastBox = self.currentBox

   373

        self.currentBox = None

   374

        self.Redraw()

   375

   376

    # Method that erase the last box and draw the new box

   377

    def Redraw(self, dc = None):

   378

        if not dc:

   379

            dc = self.drawingSurface.GetLogicalDC()

   380

        dc.SetPen(wx.Pen(wx.WHITE, 1, wx.DOT))

   381

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   382

        dc.SetLogicalFunction(wx.XOR)

   383

        if self.lastBox:

   384

            # Erase last box

   385

            dc.DrawRectangle(self.lastBox.x, self.lastBox.y, self.lastBox.width,

   386

                self.lastBox.height)

   387

        if self.currentBox:

   388

            # Draw current box

   389

            dc.DrawRectangle(self.currentBox.x, self.currentBox.y, self.currentBox.width,

   390

                self.currentBox.height)

   391

   392

    # Erase last box

   393

    def Erase(self, dc = None):

   394

        if not dc:

   395

            dc = self.drawingSurface.GetLogicalDC()

   396

        dc.SetPen(wx.Pen(wx.WHITE, 1, wx.DOT))

   397

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   398

        dc.SetLogicalFunction(wx.XOR)

   399

        if self.lastBox:

   400

            dc.DrawRectangle(self.lastBox.x, self.lastBox.y, self.lastBox.width,

   401

                self.lastBox.height)

   402

   403

    # Draw current box

   404

    def Draw(self, dc = None):

   405

        if not dc:

   406

            dc = self.drawingSurface.GetLogicalDC()

   407

        dc.SetPen(wx.Pen(wx.WHITE, 1, wx.DOT))

   408

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   409

        dc.SetLogicalFunction(wx.XOR)

   410

        if self.currentBox:

   411

            # Draw current box

   412

            dc.DrawRectangle(self.currentBox.x, self.currentBox.y, self.currentBox.width,

   413

                self.currentBox.height)

   414

   415

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

   416

#                               Viewer ToolTip

   417

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

   418

   419

"""

   420

Class that implements a custom tool tip

   421

"""

   422

   423

class ToolTip(wx.PopupWindow):

   424

   425

    # Create a rubberband by indicated on which window it must be drawn

   426

    def __init__(self, parent, tip):

   427

        wx.PopupWindow.__init__(self, parent)

   428

        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)

   429

        self.SetTip(tip)

   430

   431

        self.Bind(wx.EVT_PAINT, self.OnPaint)

   432

   433

    def SetTip(self, tip):

   434

        self.Tip = tip

   435

        wx.CallAfter(self.RefreshTip)

   436

   437

    def RefreshTip(self):

   438

        if self:

   439

            dc = wx.ClientDC(self)

   440

            w, h = dc.GetTextExtent(self.Tip)

   441

            self.SetSize(wx.Size(w + 4, h + 4))

   442

            self.Refresh()

   443

   444

    def OnPaint(self, event):

   445

        dc = wx.AutoBufferedPaintDC(self)

   446

        dc.Clear()

   447

        dc.SetPen(wx.BLACK_PEN)

   448

        dc.SetBrush(wx.Brush(wx.Colour(255, 238, 170)))

   449

        dc.BeginDrawing()

   450

        w, h = dc.GetTextExtent(self.Tip)

   451

        dc.DrawRectangle(0, 0, w + 4, h + 4)

   452

        dc.DrawText(self.Tip, 2, 2)

   453

        dc.EndDrawing()

   454

        event.Skip()

   455

   456

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

   457

#                    Helper for highlighting error in drawn text

   458

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

   459

   460

def HighlightErrorZone(dc, x, y, width, height):

   461

    dc.SetPen(wx.TRANSPARENT_PEN)

   462

    dc.SetLogicalFunction(wx.AND)

   463

    dc.SetBrush(wx.Brush(wx.Colour(0,255,0)))

   464

    dc.DrawRectangle(x, y, width, height)

   465

    dc.SetLogicalFunction(wx.XOR)

   466

    dc.SetBrush(wx.Brush(wx.Colour(255,0,0)))

   467

    dc.DrawRectangle(x, y, width, height)

   468

    dc.SetLogicalFunction(wx.COPY)

   469

   470

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

   471

#                           Graphic element base class

   472

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

   473

   474

"""

   475

Class that implements a generic graphic element

   476

"""

   477

   478

class Graphic_Element:

   479

   480

    # Create a new graphic element

   481

    def __init__(self, parent, id = None):

   482

        self.Parent = parent

   483

        self.Id = id

   484

        self.oldPos = None

   485

        self.StartPos = None

   486

        self.CurrentDrag = None

   487

        self.Handle = (None,None)

   488

        self.Dragging = False

   489

        self.Selected = False

   490

        self.Highlighted = False

   491

        self.Pos = wx.Point(0, 0)

   492

        self.Size = wx.Size(0, 0)

   493

        self.BoundingBox = wx.Rect(0, 0, 0, 0)

   494

        self.Visible = False

   495

   496

    def GetDefinition(self):

   497

        return [self.Id], []

   498

   499

    def TestVisible(self, screen):

   500

        self.Visible = self.GetRedrawRect().Intersects(screen)

   501