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

import datetime

    30

from threading import Lock,Timer

    31

    32

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

    33

#                               Common constants

    34

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

    35

    36

"""

    37

Definition of constants for dimensions of graphic elements

    38

"""

    39

    40

# FBD and SFC constants

    41

MIN_MOVE = 5                            # Minimum move before starting a element dragging

    42

CONNECTOR_SIZE = 8                      # Size of connectors

    43

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

    44

HANDLE_SIZE = 6                         # Size of the squares for handles

    45

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

    46

POINT_RADIUS = 2                        # Radius of the point of wire ends

    47

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

    48

    49

# LD constants

    50

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

    51

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

    52

LD_WIRE_SIZE = 30                       # Size of a wire between two contact

    53

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

    54

LD_POWERRAIL_WIDTH = 3                  # Width of a Powerrail

    55

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

    56

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

    57

    58

# SFC constants

    59

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

    60

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

    61

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

    62

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

    63

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

    64

SFC_WIRE_MIN_SIZE = 25                  # Size of a wire between two elements

    65

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

    66

    67

# Type definition constants for graphic elements

    68

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

    69

[CONNECTOR, CONTINUATION] = range(2)

    70

[LEFTRAIL, RIGHTRAIL] = range(2)

    71

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

    72

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

    73

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

    74

    75

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

    76

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

    77

    78

# List of value for resize handle that are valid

    79

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

    80

    81

# Contants for defining the direction of a connector

    82

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

    83

    84

# Contants for defining which mode is selected for each view 

    85

[MODE_SELECTION, MODE_BLOCK, MODE_VARIABLE, MODE_CONNECTION, MODE_COMMENT, 

    86

 MODE_COIL, MODE_CONTACT, MODE_POWERRAIL, MODE_INITIALSTEP, MODE_STEP, 

    87

 MODE_TRANSITION, MODE_DIVERGENCE, MODE_JUMP, MODE_ACTION, MODE_MOTION] = range(15)

    88

    89

# Contants for defining alignment types for graphic group 

    90

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

    91

    92

# Contants for defining which drawing mode is selected for app

    93

[FREEDRAWING_MODE, DRIVENDRAWING_MODE] = [1, 2]

    94

    95

# Color for Highlighting

    96

HIGHLIGHTCOLOR = wx.CYAN

    97

    98

# Define highlight types

    99

ERROR_HIGHLIGHT = (wx.Colour(255, 255, 0), wx.RED)

   100

SEARCH_RESULT_HIGHLIGHT = (wx.Colour(255, 165, 0), wx.WHITE)

   101

   102

# Define highlight refresh inhibition period in second

   103

REFRESH_HIGHLIGHT_PERIOD = 0.1

   104

   105

# Define tooltip wait for displaying period in second

   106

TOOLTIP_WAIT_PERIOD = 0.5

   107

   108

HANDLE_CURSORS = {

   109

    (1, 1) : 2,

   110

    (3, 3) : 2,

   111

    (1, 3) : 3,

   112

    (3, 1) : 3,

   113

    (1, 2) : 4,

   114

    (3, 2) : 4,

   115

    (2, 1) : 5,

   116

    (2, 3) : 5

   117

}

   118

   119

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

   120

    fraction = float(x) / float(n)

   121

    if constraint == -1:

   122

        xround = int(fraction)

   123

    else:

   124

        xround = round(fraction)

   125

        if constraint == 1 and xround < fraction:

   126

            xround += 1 

   127

    return int(xround * n)

   128

   129

"""

   130

Basic vector operations for calculate wire points

   131

"""

   132

   133

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

   134

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

   135

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

   136

    if normal:

   137

        return normalize(vector)

   138

    return vector

   139

   140

# Calculate the norm of a given vector

   141

def norm(v):

   142

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

   143

   144

# Normalize a given vector

   145

def normalize(v):

   146

    v_norm = norm(v)

   147

    # Verifie if it is not a null vector

   148

    if v_norm > 0:

   149

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

   150

    else:

   151

        return v

   152

   153

# Calculate the scalar product of two vectors

   154

def is_null_vector(v):

   155

    return v == (0, 0)

   156

   157

# Calculate the scalar product of two vectors

   158

def add_vectors(v1, v2):

   159

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

   160

   161

# Calculate the scalar product of two vectors

   162

def product(v1, v2):

   163

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

   164

   165

   166

"""

   167

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

   168

"""

   169

   170

def GetScaledEventPosition(event, dc, scaling):

   171

    pos = event.GetLogicalPosition(dc)

   172

    if scaling:

   173

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

   174

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

   175

    return pos

   176

   177

   178

"""

   179

Function that choose a direction during the wire points generation

   180

"""

   181

   182

def DirectionChoice(v_base, v_target, dir_target):

   183

    dir_product = product(v_base, v_target)

   184

    if dir_product < 0:

   185

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

   186

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

   187

        return dir_target

   188

    return v_base

   189

   190

SECOND = 1000000

   191

MINUTE = 60 * SECOND

   192

HOUR = 60 * MINUTE

   193

DAY = 24 * HOUR

   194

   195

def generate_time(value):

   196

    microseconds = float(value.days * DAY + value.seconds * SECOND + value.microseconds)

   197

    negative = microseconds < 0

   198

    microseconds = abs(microseconds)

   199

    data = "T#"

   200

    not_null = False

   201

    if negative:

   202

        data += "-"

   203

    for val, format in [(int(microseconds) / DAY, "%dd"),

   204

                        ((int(microseconds) % DAY) / HOUR, "%dh"),

   205

                        ((int(microseconds) % HOUR) / MINUTE, "%dm"),

   206

                        ((int(microseconds) % MINUTE) / SECOND, "%ds")]:

   207

        if val > 0 or not_null:

   208

            data += format % val

   209

            not_null = True

   210

    data += "%gms" % (microseconds % SECOND / 1000.)

   211

    return data

   212

   213

def generate_date(value):

   214

    base_date = datetime.datetime(1970, 1, 1)

   215

    date = base_date + value 

   216

    return date.strftime("DATE#%Y-%m-%d")

   217

   218

def generate_datetime(value):

   219

    base_date = datetime.datetime(1970, 1, 1)

   220

    date_time = base_date + value 

   221

    return date_time.strftime("DT#%Y-%m-%d-%H:%M:%S.%f")

   222

   223

def generate_timeofday(value):

   224

    microseconds = float(value.days * DAY + value.seconds * SECOND + value.microseconds)

   225

    negative = microseconds < 0

   226

    microseconds = abs(microseconds)

   227

    data = "TOD#"

   228

    for val, format in [(int(microseconds) / HOUR, "%2.2d:"),

   229

                        ((int(microseconds) % HOUR) / MINUTE, "%2.2d:"),

   230

                        ((int(microseconds) % MINUTE) / SECOND, "%2.2d."),

   231

                        (microseconds % SECOND, "%6.6d")]:

   232

        data += format % val

   233

    return data

   234

   235

TYPE_TRANSLATOR = {"TIME": generate_time,

   236

                   "DATE": generate_date,

   237

                   "DT": generate_datetime,

   238

                   "TOD": generate_timeofday}

   239

   240

def MiterPen(colour, width=1, style=wx.SOLID):

   241

    pen = wx.Pen(colour, width, style)

   242

    pen.SetJoin(wx.JOIN_MITER)

   243

    pen.SetCap(wx.CAP_PROJECTING)

   244

    return pen

   245

   246

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

   247

#                            Debug Data Consumer Class

   248

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

   249

   250

class DebugDataConsumer:

   251

   252

    def __init__(self):

   253

        self.LastValue = None

   254

        self.Value = None

   255

        self.DataType = None

   256

        self.LastForced = False

   257

        self.Forced = False

   258

        self.Inhibited = False

   259

   260

    def Inhibit(self, inhibit):

   261

        self.Inhibited = inhibit

   262

        if not inhibit and self.LastValue is not None:

   263

            self.SetForced(self.LastForced)

   264

            self.SetValue(self.LastValue)

   265

            self.LastValue = None

   266

   267

    def SetDataType(self, data_type):

   268

        self.DataType = data_type

   269

   270

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

   271

        value = TYPE_TRANSLATOR.get(self.DataType, lambda x:x)(value)

   272

        if self.Inhibited:

   273

            self.LastValue = value

   274

            self.LastForced = forced

   275

        else:

   276

            self.SetForced(forced)

   277

            self.SetValue(value)

   278

   279

    def SetValue(self, value):

   280

        self.Value = value

   281

   282

    def GetValue(self):

   283

        return self.Value

   284

   285

    def SetForced(self, forced):

   286

        self.Forced = forced

   287

   288

    def IsForced(self):

   289

        return self.Forced

   290

   291

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

   292

#                               Debug Viewer Class

   293

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

   294

   295

REFRESH_PERIOD = 0.1

   296

DEBUG_REFRESH_LOCK = Lock()

   297

   298

class DebugViewer:

   299

   300

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

   301

        self.DataProducer = None

   302

        self.Debug = debug

   303

        self.RegisterTick = register_tick

   304

        self.Inhibited = False

   305

   306

        self.DataConsumers = {}

   307

   308

        self.LastRefreshTime = gettime()

   309

        self.HasAcquiredLock = False

   310

        self.AccessLock = Lock()

   311

        self.TimerAccessLock = Lock()

   312

   313

        self.LastRefreshTimer = None

   314

   315

        self.SetDataProducer(producer)

   316

   317

    def __del__(self):

   318

        self.DataProducer = None

   319

        self.DeleteDataConsumers()

   320

        if self.LastRefreshTimer is not None:

   321

            self.LastRefreshTimer.Stop()

   322

   323

    def SetDataProducer(self, producer):

   324

        if self.RegisterTick and self.Debug:

   325

            if producer is not None:

   326

                producer.SubscribeDebugIECVariable("__tick__", self)

   327

            if self.DataProducer is not None:

   328

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

   329

        self.DataProducer = producer

   330

   331

    def IsDebugging(self):

   332

        return self.Debug

   333

   334

    def Inhibit(self, inhibit):

   335

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

   336

            consumer.Inhibit(inhibit)

   337

        self.Inhibited = inhibit

   338

   339

    def AddDataConsumer(self, iec_path, consumer):

   340

        if self.DataProducer is None:

   341

            return None

   342

        result = self.DataProducer.SubscribeDebugIECVariable(iec_path, consumer)

   343

        if result is not None and consumer != self:

   344

            self.DataConsumers[consumer] = iec_path

   345

            consumer.SetDataType(self.GetDataType(iec_path))

   346

        return result

   347

   348

    def RemoveDataConsumer(self, consumer):

   349

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

   350

        if iec_path is not None:

   351

            self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   352

   353

    def GetDataType(self, iec_path):

   354

        if self.DataProducer is not None:

   355

            return self.DataProducer.GetDebugIECVariableType(iec_path)

   356

        return None

   357

   358

    def ForceDataValue(self, iec_path, value):

   359

        if self.DataProducer is not None:

   360

            self.DataProducer.ForceDebugIECVariable(iec_path, value)

   361

   362

    def ReleaseDataValue(self, iec_path):

   363

        if self.DataProducer is not None:

   364

            self.DataProducer.ReleaseDebugIECVariable(iec_path)

   365

   366

    def DeleteDataConsumers(self):

   367

        if self.DataProducer is not None:

   368

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

   369

                self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   370

        self.DataConsumers = {}

   371

   372

    def ShouldRefresh(self):

   373

        if DEBUG_REFRESH_LOCK.acquire(False):

   374

            self.AccessLock.acquire()

   375

            self.HasAcquiredLock = True

   376

            self.AccessLock.release()

   377

            self.RefreshNewData()

   378

        else:

   379

            self.TimerAccessLock.acquire()

   380

            self.LastRefreshTimer = Timer(REFRESH_PERIOD, self.ShouldRefresh)

   381

            self.LastRefreshTimer.start()

   382

            self.TimerAccessLock.release()

   383

   384

    def NewDataAvailable(self, *args, **kwargs):

   385

        self.TimerAccessLock.acquire()

   386

        if self.LastRefreshTimer is not None:

   387

            self.LastRefreshTimer.cancel()

   388

            self.LastRefreshTimer=None

   389

        self.TimerAccessLock.release()

   390

        if not self.Inhibited:

   391

            current_time = gettime()

   392

            if current_time - self.LastRefreshTime > REFRESH_PERIOD and DEBUG_REFRESH_LOCK.acquire(False):

   393

                self.AccessLock.acquire()

   394

                self.HasAcquiredLock = True

   395

                self.AccessLock.release()

   396

                self.LastRefreshTime = gettime()

   397

                self.Inhibit(True)

   398

                wx.CallAfter(self.RefreshViewOnNewData, *args, **kwargs)

   399

        elif not self.IsShown() and self.HasAcquiredLock:

   400

            DebugViewer.RefreshNewData(self)

   401

   402

    def RefreshViewOnNewData(self, *args, **kwargs):

   403

        if self:

   404

            self.RefreshNewData(*args, **kwargs)

   405

            self.TimerAccessLock.acquire()

   406

            self.LastRefreshTimer = Timer(REFRESH_PERIOD, self.ShouldRefresh)

   407

            self.LastRefreshTimer.start()

   408

            self.TimerAccessLock.release()

   409

   410

    def RefreshNewData(self, *args, **kwargs):

   411

        self.Inhibit(False)

   412

        self.AccessLock.acquire()

   413

        if self.HasAcquiredLock:

   414

            DEBUG_REFRESH_LOCK.release()

   415

            self.HasAcquiredLock = False

   416

        self.AccessLock.release()

   417

   418

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

   419

#                               Viewer Rubberband

   420

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

   421

   422

"""

   423

Class that implements a rubberband

   424

"""

   425

   426

class RubberBand:

   427

   428

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

   429

    def __init__(self, viewer):

   430

        self.Viewer = viewer

   431

        self.drawingSurface = viewer.Editor

   432

        self.Reset()

   433

   434

    # Method that initializes the internal attributes of the rubberband

   435

    def Reset(self):

   436

        self.startPoint = None

   437

        self.currentBox = None

   438

        self.lastBox = None

   439

   440

    # Method that return if a box is currently edited

   441

    def IsShown(self):

   442

        return self.currentBox != None

   443

   444

    # Method that returns the currently edited box

   445

    def GetCurrentExtent(self):

   446

        if self.currentBox is None:

   447

            return self.lastBox

   448

        return self.currentBox

   449

   450

    # Method called when a new box starts to be edited

   451

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

   452

        pos = GetScaledEventPosition(event, dc, scaling)

   453

        # Save the point for calculate the box position and size

   454

        self.startPoint = pos

   455

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

   456

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

   457

        self.Redraw()

   458

   459

    # Method called when dragging with a box edited

   460

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

   461

        pos = GetScaledEventPosition(event, dc, scaling)

   462

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

   463

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

   464

            self.currentBox.height)

   465

        # Calculate new position and size of the box 

   466

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

   467

            self.currentBox.x = self.startPoint.x

   468

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

   469

        else:

   470

            self.currentBox.x = pos.x

   471

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

   472

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

   473

            self.currentBox.y = self.startPoint.y

   474

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

   475

        else:

   476

            self.currentBox.y = pos.y

   477

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

   478

        self.Redraw()

   479

   480

    # Method called when dragging is stopped

   481

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

   482

        self.drawingSurface.SetCursor(wx.NullCursor)

   483

        self.lastBox = self.currentBox

   484

        self.currentBox = None

   485

        self.Redraw()

   486

   487

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

   488

    def Redraw(self, dc = None):

   489

        if dc is None:

   490

            dc = self.Viewer.GetLogicalDC()

   491

        scalex, scaley = dc.GetUserScale()

   492

        dc.SetUserScale(1, 1)

   493

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

   494

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   495

        dc.SetLogicalFunction(wx.XOR)

   496

        if self.lastBox:

   497

            # Erase last box

   498

            dc.DrawRectangle(self.lastBox.x * scalex, self.lastBox.y * scaley, 

   499

                             self.lastBox.width * scalex, self.lastBox.height * scaley)

   500

        if self.currentBox:

   501

            # Draw current box

   502

            dc.DrawRectangle(self.currentBox.x * scalex, self.currentBox.y * scaley, 

   503

                             self.currentBox.width * scalex, self.currentBox.height * scaley)

   504

        dc.SetUserScale(scalex, scaley)

   505

   506

    # Erase last box

   507

    def Erase(self, dc = None):

   508

        if dc is None:

   509

            dc = self.Viewer.GetLogicalDC()

   510

        scalex, scaley = dc.GetUserScale()

   511

        dc.SetUserScale(1, 1)

   512

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

   513

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   514

        dc.SetLogicalFunction(wx.XOR)

   515

        if self.lastBox:

   516

            dc.DrawRectangle(self.lastBox.x * scalex, self.lastBox.y * scaley, 

   517

                             self.lastBox.width * scalex, self.lastBox.height * scalex)

   518

        dc.SetUserScale(scalex, scaley)

   519

   520

    # Draw current box

   521

    def Draw(self, dc = None):

   522

        if dc is None:

   523

            dc = self.Viewer.GetLogicalDC()

   524

        scalex, scaley = dc.GetUserScale()