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 math import *

    27

    28

    29

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

    30

#                               Common constants

    31

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

    32

    33

"""

    34

Definition of constants for dimensions of graphic elements

    35

"""

    36

    37

# FBD and SFC constants

    38

MIN_MOVE = 5                            # Minimum move before starting a element dragging

    39

CONNECTOR_SIZE = 8                      # Size of connectors

    40

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

    41

HANDLE_SIZE = 6                         # Size of the squares for handles

    42

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

    43

POINT_RADIUS = 2                        # Radius of the point of wire ends

    44

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

    45

    46

# LD constants

    47

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

    48

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

    49

LD_WIRE_SIZE = 30                       # Size of a wire between two contact

    50

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

    51

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

    52

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

    53

    54

# SFC constants

    55

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

    56

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

    57

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

    58

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

    59

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

    60

SFC_WIRE_MIN_SIZE = 25                  # Size of a wire between two elements

    61

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

    62

    63

# Type definition constants for graphic elements

    64

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

    65

[CONNECTOR, CONTINUATION] = range(2)

    66

[LEFTRAIL, RIGHTRAIL] = range(2)

    67

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

    68

[COIL_NORMAL, COIL_REVERSE, COIL_SET, COIL_RESET] = range(4)

    69

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

    70

    71

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

    72

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

    73

    74

# List of value for resize handle that are valid

    75

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

    76

    77

# Contants for defining the direction of a connector

    78

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

    79

    80

# Contants for defining which mode is selected for each view 

    81

[MODE_SELECTION, MODE_BLOCK, MODE_VARIABLE, MODE_CONNECTION, MODE_COMMENT, MODE_WIRE,

    82

 MODE_COIL, MODE_CONTACT, MODE_POWERRAIL, MODE_INITIALSTEP, MODE_STEP, MODE_TRANSITION,

    83

 MODE_DIVERGENCE, MODE_JUMP, MODE_ACTION] = range(15)

    84

    85

# Contants for defining which drawing mode is selected for app

    86

[FREEDRAWING_MODE, DRIVENDRAWING_MODE] = [1, 2]

    87

    88

CURSORS = None

    89

    90

def ResetCursors():

    91

    global CURSORS

    92

    if CURSORS == None:

    93

        CURSORS = [wx.NullCursor, 

    94

                   wx.StockCursor(wx.CURSOR_HAND),

    95

                   wx.StockCursor(wx.CURSOR_SIZENWSE),

    96

                   wx.StockCursor(wx.CURSOR_SIZENESW),

    97

                   wx.StockCursor(wx.CURSOR_SIZEWE),

    98

                   wx.StockCursor(wx.CURSOR_SIZENS)]

    99

   100

HANDLE_CURSORS = {

   101

    (1, 1) : 2,

   102

    (3, 3) : 2,

   103

    (1, 3) : 3,

   104

    (3, 1) : 3,

   105

    (1, 2) : 4,

   106

    (3, 2) : 4,

   107

    (2, 1) : 5,

   108

    (2, 3) : 5

   109

}

   110

   111

"""

   112

Basic vector operations for calculate wire points

   113

"""

   114

   115

# Calculate the scalar product of two vectors

   116

def product(v1, v2):

   117

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

   118

   119

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

   120

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

   121

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

   122

    if normal:

   123

        return normalize(vector)

   124

    return vector

   125

   126

# Calculate the norm of a given vector

   127

def norm(v):

   128

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

   129

   130

# Normalize a given vector

   131

def normalize(v):

   132

    v_norm = norm(v)

   133

    # Verifie if it is not a null vector

   134

    if v_norm > 0:

   135

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

   136

    else:

   137

        return v

   138

   139

   140

"""

   141

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

   142

"""

   143

   144

def GetScaledEventPosition(event, dc, scaling):

   145

    pos = event.GetLogicalPosition(dc)

   146

    if scaling:

   147

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

   148

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

   149

    return pos

   150

   151

   152

"""

   153

Function that choose a direction during the wire points generation

   154

"""

   155

   156

def DirectionChoice(v_base, v_target, dir_target):

   157

    dir_product = product(v_base, v_target)

   158

    if dir_product < 0:

   159

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

   160

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

   161

        return dir_target

   162

    return v_base

   163

   164

   165

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

   166

#                               Viewer Rubberband

   167

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

   168

   169

"""

   170

Class that implements a rubberband

   171

"""

   172

   173

class RubberBand:

   174

   175

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

   176

    def __init__(self, drawingSurface):

   177

        self.drawingSurface = drawingSurface

   178

        self.Reset()

   179

   180

    # Method that initializes the internal attributes of the rubberband

   181

    def Reset(self):

   182

        self.startPoint = None

   183

        self.currentBox = None

   184

        self.lastBox = None

   185

   186

    # Method that return if a box is currently edited

   187

    def IsShown(self):

   188

        return self.currentBox != None

   189

   190

    # Method that returns the currently edited box

   191

    def GetCurrentExtent(self):

   192

        return self.currentBox

   193

   194

    # Method called when a new box starts to be edited

   195

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

   196

        pos = GetScaledEventPosition(event, dc, scaling)

   197

        # Save the point for calculate the box position and size

   198

        self.startPoint = pos

   199

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

   200

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

   201

        self.Redraw()

   202

   203

    # Method called when dragging with a box edited

   204

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

   205

        pos = GetScaledEventPosition(event, dc, scaling)

   206

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

   207

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

   208

            self.currentBox.height)

   209

        # Calculate new position and size of the box 

   210

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

   211

            self.currentBox.x = self.startPoint.x

   212

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

   213

        else:

   214

            self.currentBox.x = pos.x

   215

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

   216

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

   217

            self.currentBox.y = self.startPoint.y

   218

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

   219

        else:

   220

            self.currentBox.y = pos.y

   221

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

   222

        self.Redraw()

   223

   224

    # Method called when dragging is stopped

   225

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

   226

        self.drawingSurface.SetCursor(wx.NullCursor)

   227

        self.lastBox = self.currentBox

   228

        self.currentBox = None

   229

        self.Redraw()

   230

   231

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

   232

    def Redraw(self):

   233

        dc = self.drawingSurface.GetLogicalDC()

   234

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

   235

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   236

        dc.SetLogicalFunction(wx.XOR)

   237

        if self.lastBox:

   238

            # Erase last box

   239

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

   240

                self.lastBox.height)

   241

        if self.currentBox:

   242

            # Draw current box

   243

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

   244

                self.currentBox.height)

   245

   246

    # Erase last box

   247

    def Erase(self):

   248

        dc = self.drawingSurface.GetLogicalDC()

   249

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

   250

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   251

        dc.SetLogicalFunction(wx.XOR)

   252

        if self.lastBox:

   253

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

   254

                self.lastBox.height)

   255

   256

    # Draw current box

   257

    def Draw(self):

   258

        dc = self.drawingSurface.GetLogicalDC()

   259

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

   260

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   261

        dc.SetLogicalFunction(wx.XOR)

   262

        if self.currentBox:

   263

            # Draw current box

   264

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

   265

                self.currentBox.height)

   266

   267

   268

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

   269

#                           Graphic element base class

   270

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

   271

   272

"""

   273

Class that implements a generic graphic element

   274

"""

   275

   276

class Graphic_Element:

   277

   278

    # Create a new graphic element

   279

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

   280

        self.Parent = parent

   281

        self.Id = id

   282

        self.oldPos = None

   283

        self.Handle = False

   284

        self.Dragging = False

   285

        self.Selected = False

   286

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

   287

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

   288

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

   289

        self.CurrentCursor = 0

   290

        ResetCursors()

   291

   292

    # Make a clone of this element

   293

    def Clone(self):

   294

        return Graphic_Element(self.Parent, self.Id)

   295

   296

    # Changes the block position

   297

    def SetPosition(self, x, y):

   298

        self.Pos.x = x

   299

        self.Pos.y = y

   300

        self.RefreshConnected()

   301

        self.RefreshBoundingBox()

   302

   303

    # Returns the block position

   304

    def GetPosition(self):

   305

        return self.Pos.x, self.Pos.y

   306

   307

    # Changes the element size

   308

    def SetSize(self, width, height):

   309

        self.Size.SetWidth(width)

   310

        self.Size.SetHeight(height)

   311

        self.RefreshConnectors()

   312

        self.RefreshBoundingBox()

   313

   314

    # Returns the element size

   315

    def GetSize(self):

   316

        return self.Size.GetWidth(), self.Size.GetHeight()

   317

   318

    # Refresh the element Bounding Box

   319

    def RefreshBoundingBox(self):

   320

        self.BoundingBox = wx.Rect(self.Pos.x, self.Pos.y, self.Size[0], self.Size[1])

   321

   322

    # Refresh the element connectors position

   323

    def RefreshConnectors(self):

   324

        pass

   325

   326

    # Refresh the position of wires connected to element inputs and outputs

   327

    def RefreshConnected(self):

   328

        pass

   329

   330

    # Change the parent

   331

    def SetParent(self, parent):

   332

        self.Parent = parent

   333

   334

    # Override this method for defining the method to call for deleting this element

   335

    def Delete(self):

   336

        pass

   337

   338

    # Returns the Id

   339

    def GetId(self):

   340

        return self.Id

   341

   342

    # Returns if the point given is in the bounding box

   343

    def HitTest(self, pt):

   344

        rect = self.BoundingBox

   345

        return rect.InsideXY(pt.x, pt.y)

   346

   347

    # Returns if the point given is in the bounding box

   348

    def IsInSelection(self, rect):

   349

        return rect.InsideXY(self.BoundingBox.x, self.BoundingBox.y) and rect.InsideXY(self.BoundingBox.x + self.BoundingBox.width, self.BoundingBox.y + self.BoundingBox.height)

   350

   351

    # Override this method for refreshing the bounding box

   352

    def RefreshBoundingBox(self):

   353

        pass

   354

   355

    # Returns the bounding box

   356

    def GetBoundingBox(self):

   357

        return self.BoundingBox

   358

   359

    # Change the variable that indicates if this element is selected

   360

    def SetSelected(self, selected):

   361

        self.Selected = selected

   362

   363

    # Test if the point is on a handle of this element

   364

    def TestHandle(self, pt):

   365

        extern_rect = wx.Rect(self.BoundingBox.x - HANDLE_SIZE - 2, self.BoundingBox.y - HANDLE_SIZE - 2, 

   366

            self.BoundingBox.width + 2 * HANDLE_SIZE + 4, self.BoundingBox.height + 2 * HANDLE_SIZE + 4)

   367

        intern_rect = wx.Rect(self.BoundingBox.x - 2, self.BoundingBox.y - 2, 

   368

            self.BoundingBox.width + 4, self.BoundingBox.height + 4)

   369

        # Verify that this element is selected

   370

        if self.Selected and extern_rect.InsideXY(pt.x, pt.y) and not intern_rect.InsideXY(pt.x, pt.y):

   371

            # Find if point is on a handle horizontally

   372

            if self.BoundingBox.x - HANDLE_SIZE - 2 <= pt.x < self.BoundingBox.x - 2:

   373

                handle_x = 1

   374

            elif self.BoundingBox.x + (self.BoundingBox.width - HANDLE_SIZE) / 2 <= pt.x < self.BoundingBox.x + (self.BoundingBox.width + HANDLE_SIZE) / 2:

   375

                handle_x = 2

   376

            elif self.BoundingBox.x + self.BoundingBox.width + 2 <= pt.x < self.BoundingBox.x + self.BoundingBox.width + HANDLE_SIZE + 2:

   377

                handle_x = 3

   378

            else:

   379

                handle_x = 0

   380

            # Find if point is on a handle vertically

   381

            if self.BoundingBox.y - HANDLE_SIZE - 2 <= pt.y < self.BoundingBox.y - 2:

   382

                handle_y = 1

   383

            elif self.BoundingBox.y + (self.BoundingBox.height - HANDLE_SIZE) / 2 <= pt.y < self.BoundingBox.y + (self.BoundingBox.height + HANDLE_SIZE) / 2:

   384

                handle_y = 2

   385

            elif self.BoundingBox.y + self.BoundingBox.height - 2 <= pt.y < self.BoundingBox.y + self.BoundingBox.height + HANDLE_SIZE + 2:

   386

                handle_y = 3

   387

            else:

   388

                handle_y = 0

   389

            # Verify that the result is valid

   390

            if (handle_x, handle_y) in VALID_HANDLES:

   391

                return handle_x, handle_y

   392

        return 0, 0

   393

   394

    # Method called when a LeftDown event have been generated

   395

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

   396

        pos = event.GetLogicalPosition(dc)

   397

        # Test if an handle have been clicked

   398

        handle = self.TestHandle(pos)

   399

        # Find which type of handle have been clicked,

   400

        # Save a resize event and change the cursor

   401

        cursor = HANDLE_CURSORS.get(handle, 1)

   402

        if cursor != self.CurrentCursor:

   403

            self.Parent.SetCursor(CURSORS[cursor])

   404

            self.CurrentCursor = cursor

   405

        if cursor > 1:

   406

            self.Handle = (HANDLE_RESIZE, handle)

   407

        else:

   408

            self.Handle = (HANDLE_MOVE, None)

   409

            self.SetSelected(False)

   410

        # Initializes the last position

   411

        self.oldPos = GetScaledEventPosition(event, dc, scaling)

   412

   413

    # Method called when a LeftUp event have been generated

   414

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

   415

        # If a dragging have been initiated

   416

        if self.Dragging and self.oldPos:

   417

            # Calculate the movement of cursor and refreshes the element state

   418

            pos = GetScaledEventPosition(event, dc, scaling)

   419

            movex = pos.x - self.oldPos.x

   420

            movey = pos.y - self.oldPos.y

   421

            self.ProcessDragging(movex, movey)

   422

            self.RefreshModel()

   423

            self.Parent.RefreshBuffer()

   424

        if self.CurrentCursor != 0:

   425

            self.Parent.SetCursor(CURSORS[0])

   426

            self.CurrentCursor = 0

   427

        self.SetSelected(True)

   428

        self.oldPos = None

   429

   430

    # Method called when a RightUp event have been generated

   431

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

   432

        self.SetSelected(True)

   433

        self.oldPos = None

   434

   435

    # Method called when a LeftDClick event have been generated

   436

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

   437

        pass

   438

   439

    # Method called when a Motion event have been generated

   440

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

   441

        # If the cursor is dragging and the element have been clicked

   442

        if event.Dragging() and self.oldPos:

   443

            # Calculate the movement of cursor

   444

            pos = GetScaledEventPosition(event, dc, scaling)

   445

            movex = pos.x - self.oldPos.x

   446

            movey = pos.y - self.oldPos.y

   447

            # If movement is greater than MIN_MOVE then a dragging is initiated

   448

            if not self.Dragging and (abs(movex) > MIN_MOVE or abs(movey) > MIN_MOVE):

   449

                self.Dragging = True

   450

            # If a dragging have been initiated, refreshes the element state

   451

            if self.Dragging:

   452

                self.oldPos = pos

   453

                self.ProcessDragging(movex, movey)

   454

        # If cursor just pass over the element, changes the cursor if it is on a handle

   455

        else:

   456

            pos = event.GetLogicalPosition(dc)

   457

            handle = self.TestHandle(pos)

   458

            # Find which type of handle have been clicked,

   459

            # Save a resize event and change the cursor

   460

            cursor = HANDLE_CURSORS.get(handle, 0)

   461

            if cursor != self.CurrentCursor:

   462

                self.Parent.SetCursor(CURSORS[cursor])

   463

                self.CurrentCursor = cursor

   464

   465

    # Moves the element

   466

    def Move(self, dx, dy, exclude = []):

   467

        self.Pos.x += dx

   468

        self.Pos.y += dy

   469

        self.RefreshConnected(exclude)

   470

        self.RefreshBoundingBox()

   471

   472

    # Resizes the element from position and size given

   473

    def Resize(self, x, y, width, height):

   474

        self.Move(x, y)

   475

        self.SetSize(width, height)

   476

   477

    # Refreshes the element state according to move defined and handle selected

   478

    def ProcessDragging(self, movex, movey):

   479

        handle_type, handle = self.Handle

   480

        # If it is a resize handle, calculate the values from resizing

   481

        if handle_type == HANDLE_RESIZE:

   482

            x, y = 0, 0

   483

            width, height = self.GetSize()

   484

            if handle[0] == 1:

   485

                x = movex

   486

                width -= movex

   487

            elif handle[0] == 3:

   488

                width += movex

   489

            if handle[1] == 1:

   490

                y = movey

   491

                height -= movey

   492

            elif handle[1] == 3:

   493

                height += movey

   494

            # Verify that new size is not lesser than minimum

   495

            min_width, min_height = self.GetMinSize()

   496

            if width >= min_width and height >= min_height:

   497

                self.Resize(x, y, width, height)

   498

        # If it is a move handle, Move this element

   499

        elif handle_type == HANDLE_MOVE:

   500

            self.Move(movex, movey)

   501

   502

    # Override this method for defining the method to call for refreshing the model of this element

   503

    def RefreshModel(self, move=True):

   504

        pass

   505

   506

    # Draws the handles of this element if it is selected

   507

    def Draw(self, dc):

   508

        if self.Selected:

   509

            dc.SetPen(wx.BLACK_PEN)

   510

            dc.SetBrush(wx.BLACK_BRUSH)

   511

            dc.DrawRectangle(self.BoundingBox.x - HANDLE_SIZE - 2, self.BoundingBox.y - HANDLE_SIZE - 2, HANDLE_SIZE, HANDLE_SIZE)

   512

            dc.DrawRectangle(self.BoundingBox.x + (self.BoundingBox.width - HANDLE_SIZE) / 2,

   513

                self.BoundingBox.y - HANDLE_SIZE - 2, HANDLE_SIZE, HANDLE_SIZE)

   514

            dc.DrawRectangle(self.BoundingBox.x + self.BoundingBox.width + 2, 

   515

                self.BoundingBox.y - HANDLE_SIZE - 2, HANDLE_SIZE, HANDLE_SIZE)