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

    31

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

    32

#                               Common constants

    33

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

    34

    35

"""

    36

Definition of constants for dimensions of graphic elements

    37

"""

    38

    39

# FBD and SFC constants

    40

MIN_MOVE = 5                            # Minimum move before starting a element dragging

    41

CONNECTOR_SIZE = 8                      # Size of connectors

    42

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

    43

HANDLE_SIZE = 6                         # Size of the squares for handles

    44

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

    45

POINT_RADIUS = 2                        # Radius of the point of wire ends

    46

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

    47

    48

# LD constants

    49

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

    50

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

    51

LD_WIRE_SIZE = 30                       # Size of a wire between two contact

    52

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

    53

LD_POWERRAIL_WIDTH = 3                  # Width of a Powerrail

    54

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

    55

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

    56

    57

# SFC constants

    58

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

    59

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

    60

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

    61

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

    62

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

    63

SFC_WIRE_MIN_SIZE = 25                  # Size of a wire between two elements

    64

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

    65

    66

# Type definition constants for graphic elements

    67

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

    68

[CONNECTOR, CONTINUATION] = range(2)

    69

[LEFTRAIL, RIGHTRAIL] = range(2)

    70

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

    71

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

    72

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

    73

    74

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

    75

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

    76

    77

# List of value for resize handle that are valid

    78

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

    79

    80

# Contants for defining the direction of a connector

    81

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

    82

    83

# Contants for defining which mode is selected for each view 

    84

[MODE_SELECTION, MODE_BLOCK, MODE_VARIABLE, MODE_CONNECTION, MODE_COMMENT, 

    85

 MODE_COIL, MODE_CONTACT, MODE_POWERRAIL, MODE_INITIALSTEP, MODE_STEP, 

    86

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

    87

    88

# Contants for defining alignment types for graphic group 

    89

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

    90

    91

# Contants for defining which drawing mode is selected for app

    92

[FREEDRAWING_MODE, DRIVENDRAWING_MODE] = [1, 2]

    93

    94

# Color for Highlighting

    95

HIGHLIGHTCOLOR = wx.CYAN

    96

    97

HANDLE_CURSORS = {

    98

    (1, 1) : 2,

    99

    (3, 3) : 2,

   100

    (1, 3) : 3,

   101

    (3, 1) : 3,

   102

    (1, 2) : 4,

   103

    (3, 2) : 4,

   104

    (2, 1) : 5,

   105

    (2, 3) : 5

   106

}

   107

   108

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

   109

    fraction = float(x) / float(n)

   110

    if constraint == - 1:

   111

        xround = int(fraction)

   112

    else:

   113

        xround = round(fraction)

   114

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

   115

            xround += 1

   116

    return xround * n

   117

   118

"""

   119

Basic vector operations for calculate wire points

   120

"""

   121

   122

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

   123

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

   124

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

   125

    if normal:

   126

        return normalize(vector)

   127

    return vector

   128

   129

# Calculate the norm of a given vector

   130

def norm(v):

   131

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

   132

   133

# Normalize a given vector

   134

def normalize(v):

   135

    v_norm = norm(v)

   136

    # Verifie if it is not a null vector

   137

    if v_norm > 0:

   138

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

   139

    else:

   140

        return v

   141

   142

# Calculate the scalar product of two vectors

   143

def is_null_vector(v):

   144

    return v == (0, 0)

   145

   146

# Calculate the scalar product of two vectors

   147

def add_vectors(v1, v2):

   148

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

   149

   150

# Calculate the scalar product of two vectors

   151

def product(v1, v2):

   152

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

   153

   154

   155

"""

   156

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

   157

"""

   158

   159

def GetScaledEventPosition(event, dc, scaling):

   160

    pos = event.GetLogicalPosition(dc)

   161

    if scaling:

   162

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

   163

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

   164

    return pos

   165

   166

   167

"""

   168

Function that choose a direction during the wire points generation

   169

"""

   170

   171

def DirectionChoice(v_base, v_target, dir_target):

   172

    dir_product = product(v_base, v_target)

   173

    if dir_product < 0:

   174

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

   175

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

   176

        return dir_target

   177

    return v_base

   178

   179

SECOND = 1000000

   180

MINUTE = 60 * SECOND

   181

HOUR = 60 * MINUTE

   182

DAY = 24 * HOUR

   183

   184

def generate_time(value):

   185

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

   186

    negative = microseconds < 0

   187

    microseconds = abs(microseconds)

   188

    data = "T#"

   189

    not_null = False

   190

    if negative:

   191

        data += "-"

   192

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

   193

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

   194

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

   195

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

   196

        if val > 0 or not_null:

   197

            data += format % val

   198

            not_null = True

   199

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

   200

    return data

   201

   202

def generate_date(value):

   203

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

   204

    date = base_date + value 

   205

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

   206

   207

def generate_datetime(value):

   208

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

   209

    date_time = base_date + value 

   210

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

   211

   212

def generate_timeofday(value):

   213

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

   214

    negative = microseconds < 0

   215

    microseconds = abs(microseconds)

   216

    data = "TOD#"

   217

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

   218

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

   219

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

   220

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

   221

        data += format % val

   222

    return data

   223

   224

TYPE_TRANSLATOR = {"TIME": generate_time,

   225

                   "DATE": generate_date,

   226

                   "DT": generate_datetime,

   227

                   "TOD": generate_timeofday}

   228

   229

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

   230

#                            Debug Data Consumer Class

   231

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

   232

   233

class DebugDataConsumer:

   234

   235

    def __init__(self):

   236

        self.LastValue = None

   237

        self.Value = None

   238

        self.DataType = None

   239

        self.LastForced = False

   240

        self.Forced = False

   241

        self.Inhibited = False

   242

   243

    def Inhibit(self, inhibit):

   244

        self.Inhibited = inhibit

   245

        if not inhibit and self.LastValue is not None:

   246

            self.SetForced(self.LastForced)

   247

            self.SetValue(self.LastValue)

   248

            self.LastValue = None

   249

   250

    def SetDataType(self, data_type):

   251

        self.DataType = data_type

   252

   253

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

   254

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

   255

        if self.Inhibited:

   256

            self.LastValue = value

   257

            self.LastForced = forced

   258

        else:

   259

            self.SetForced(forced)

   260

            self.SetValue(value)

   261

   262

    def SetValue(self, value):

   263

        self.Value = value

   264

   265

    def GetValue(self):

   266

        return self.Value

   267

   268

    def SetForced(self, forced):

   269

        self.Forced = forced

   270

   271

    def IsForced(self):

   272

        return self.Forced

   273

   274

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

   275

#                               Debug Viewer Class

   276

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

   277

   278

REFRESH_PERIOD = 0.1

   279

   280

class DebugViewer:

   281

   282

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

   283

        self.DataProducer = None

   284

        self.Debug = debug

   285

        self.RegisterTick = register_tick

   286

        self.Inhibited = False

   287

   288

        self.DataConsumers = {}

   289

   290

        self.LastRefreshTime = gettime()

   291

   292

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

   293

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

   294

   295

        self.SetDataProducer(producer)

   296

   297

    def __del__(self):

   298

        self.DataProducer = None

   299

        self.DeleteDataConsumers()

   300

        self.RefreshTimer.Stop()

   301

   302

    def SetDataProducer(self, producer):

   303

        if self.RegisterTick and self.Debug:

   304

            if producer is not None:

   305

                producer.SubscribeDebugIECVariable("__tick__", self)

   306

            if self.DataProducer is not None:

   307

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

   308

        self.DataProducer = producer

   309

   310

    def IsDebugging(self):

   311

        return self.Debug

   312

   313

    def Inhibit(self, inhibit):

   314

        self.Inhibited = inhibit

   315

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

   316

            consumer.Inhibit(inhibit)

   317

   318

    def AddDataConsumer(self, iec_path, consumer):

   319

        if self.DataProducer is None:

   320

            return False

   321

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

   322

        if result is not None and consumer != self:

   323

            self.DataConsumers[consumer] = iec_path

   324

            consumer.SetDataType(self.GetDataType(iec_path))

   325

        return result

   326

   327

    def RemoveDataConsumer(self, consumer):

   328

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

   329

        if iec_path is not None:

   330

            self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   331

   332

    def GetDataType(self, iec_path):

   333

        if self.DataProducer is not None:

   334

            return self.DataProducer.GetDebugIECVariableType(iec_path)

   335

        return None

   336

   337

    def ForceDataValue(self, iec_path, value):

   338

        if self.DataProducer is not None:

   339

            self.DataProducer.ForceDebugIECVariable(iec_path, value)

   340

   341

    def ReleaseDataValue(self, iec_path):

   342

        if self.DataProducer is not None:

   343

            self.DataProducer.ReleaseDebugIECVariable(iec_path)

   344

   345

    def DeleteDataConsumers(self):

   346

        if self.DataProducer is not None:

   347

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

   348

                self.DataProducer.UnsubscribeDebugIECVariable(iec_path, consumer)

   349

        self.DataConsumers = {}

   350

   351

    def OnRefreshTimer(self, event):

   352

        self.RefreshNewData()

   353

        event.Skip()

   354

   355

    def NewDataAvailable(self):

   356

        self.RefreshTimer.Stop()

   357

        if not self.Inhibited:

   358

            current_time = gettime()

   359

            if current_time - self.LastRefreshTime > REFRESH_PERIOD:

   360

                self.LastRefreshTime = current_time

   361

                self.Inhibit(True)

   362

                wx.CallAfter(self.RefreshViewOnNewData)

   363

   364

    def RefreshViewOnNewData(self):

   365

        if self:

   366

            self.RefreshNewData()

   367

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

   368

   369

    def RefreshNewData(self):

   370

        self.Inhibit(False)

   371

   372

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

   373

#                               Viewer Rubberband

   374

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

   375

   376

"""

   377

Class that implements a rubberband

   378

"""

   379

   380

class RubberBand:

   381

   382

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

   383

    def __init__(self, drawingSurface):

   384

        self.drawingSurface = drawingSurface

   385

        self.Reset()

   386

   387

    # Method that initializes the internal attributes of the rubberband

   388

    def Reset(self):

   389

        self.startPoint = None

   390

        self.currentBox = None

   391

        self.lastBox = None

   392

   393

    # Method that return if a box is currently edited

   394

    def IsShown(self):

   395

        return self.currentBox != None

   396

   397

    # Method that returns the currently edited box

   398

    def GetCurrentExtent(self):

   399

        return self.currentBox

   400

   401

    # Method called when a new box starts to be edited

   402

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

   403

        pos = GetScaledEventPosition(event, dc, scaling)

   404

        # Save the point for calculate the box position and size

   405

        self.startPoint = pos

   406

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

   407

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

   408

        self.Redraw()

   409

   410

    # Method called when dragging with a box edited

   411

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

   412

        pos = GetScaledEventPosition(event, dc, scaling)

   413

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

   414

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

   415

            self.currentBox.height)

   416

        # Calculate new position and size of the box 

   417

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

   418

            self.currentBox.x = self.startPoint.x

   419

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

   420

        else:

   421

            self.currentBox.x = pos.x

   422

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

   423

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

   424

            self.currentBox.y = self.startPoint.y

   425

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

   426

        else:

   427

            self.currentBox.y = pos.y

   428

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

   429

        self.Redraw()

   430

   431

    # Method called when dragging is stopped

   432

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

   433

        self.drawingSurface.SetCursor(wx.NullCursor)

   434

        self.lastBox = self.currentBox

   435

        self.currentBox = None

   436

        self.Redraw()

   437

   438

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

   439

    def Redraw(self, dc = None):

   440

        if not dc:

   441

            dc = self.drawingSurface.GetLogicalDC()

   442

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

   443

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   444

        dc.SetLogicalFunction(wx.XOR)

   445

        if self.lastBox:

   446

            # Erase last box

   447

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

   448

                self.lastBox.height)

   449

        if self.currentBox:

   450

            # Draw current box

   451

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

   452

                self.currentBox.height)

   453

   454

    # Erase last box

   455

    def Erase(self, dc = None):

   456

        if not dc:

   457

            dc = self.drawingSurface.GetLogicalDC()

   458

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

   459

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   460

        dc.SetLogicalFunction(wx.XOR)

   461

        if self.lastBox:

   462

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

   463

                self.lastBox.height)

   464

   465

    # Draw current box

   466

    def Draw(self, dc = None):

   467

        if not dc:

   468

            dc = self.drawingSurface.GetLogicalDC()

   469

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

   470

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   471

        dc.SetLogicalFunction(wx.XOR)

   472

        if self.currentBox:

   473

            # Draw current box

   474

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

   475

                self.currentBox.height)

   476

   477

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

   478

#                               Viewer ToolTip

   479

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

   480

   481

"""

   482

Class that implements a custom tool tip

   483

"""

   484

   485

class ToolTip(wx.PopupWindow):

   486

   487

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

   488

    def __init__(self, parent, tip):

   489

        wx.PopupWindow.__init__(self, parent)

   490

        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)

   491

        self.SetTip(tip)

   492

   493

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

   494

   495

    def SetTip(self, tip):

   496

        self.Tip = tip

   497

        wx.CallAfter(self.RefreshTip)

   498

   499

    def RefreshTip(self):

   500