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): 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 Lesser 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

#Lesser General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU Lesser 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

from wxPython.wx import *

    26

import wx

    27

from math import *

    28

    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_OFFSET = (10, 10)                # Distance (x, y) between each comment and rung of the ladder

    53

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

    54

    55

# SFC constants

    56

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

    57

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

    58

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

    59

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

    60

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

    61

SFC_WIRE_MIN_SIZE = 25                # Size of a wire between two elements

    62

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

    63

    64

# Type definition constants for graphic elements

    65

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

    66

[CONNECTOR, CONTINUATION] = range(2)

    67

[LEFTRAIL, RIGHTRAIL] = range(2)

    68

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

    69

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

    70

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

    71

    72

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

    73

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

    74

    75

# List of value for resize handle that are valid

    76

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

    77

    78

# Contants for defining the direction of a connector

    79

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

    80

    81

# Contants for defining which mode is selected for each view 

    82

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

    83

 MODE_INITIAL_STEP] = range(7)

    84

    85

"""

    86

Basic vector operations for calculate wire points

    87

"""

    88

    89

# Calculate the scalar product of two vectors

    90

def product(v1, v2):

    91

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

    92

    93

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

    94

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

    95

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

    96

    if normal:

    97

        return normalize(vector)

    98

    return vector

    99

   100

# Calculate the norm of a given vector

   101

def norm(v):

   102

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

   103

   104

# Normalize a given vector

   105

def normalize(v):

   106

    v_norm = norm(v)

   107

    # Verifie if it is not a null vector

   108

    if v_norm > 0:

   109

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

   110

    else:

   111

        return v

   112

   113

   114

"""

   115

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

   116

"""

   117

   118

def GetScaledEventPosition(event, scaling):

   119

    pos = event.GetPosition()

   120

    if scaling:

   121

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

   122

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

   123

    return pos

   124

   125

   126

"""

   127

Function that choose a direction during the wire points generation

   128

"""

   129

   130

def DirectionChoice(v_base, v_target, dir_target):

   131

    dir_product = product(v_base, v_target)

   132

    if dir_product < 0:

   133

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

   134

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

   135

        return dir_target

   136

    return v_base

   137

   138

   139

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

   140

#                               Viewer Rubberband

   141

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

   142

   143

"""

   144

Class that implements a rubberband

   145

"""

   146

   147

class RubberBand:

   148

   149

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

   150

    def __init__(self, drawingSurface):

   151

        self.drawingSurface = drawingSurface

   152

        self.Reset()

   153

   154

    # Method that initializes the internal attributes of the rubberband

   155

    def Reset(self):

   156

        self.startPoint = None

   157

        self.currentBox = None

   158

        self.lastBox = None

   159

   160

    # Method that return if a box is currently edited

   161

    def IsShown(self):

   162

        return self.currentBox != None

   163

   164

    # Method that returns the currently edited box

   165

    def GetCurrentExtent(self):

   166

        return self.currentBox

   167

   168

    # Method called when a new box starts to be edited

   169

    def OnLeftDown(self, event, scaling):

   170

        pos = GetScaledEventPosition(event, scaling)

   171

        # Save the point for calculate the box position and size

   172

        self.startPoint = pos

   173

        self.currentBox = wxRect(pos.x, pos.y, 0, 0)

   174

        self.drawingSurface.SetCursor(wxStockCursor(wxCURSOR_CROSS))

   175

        self.Redraw()

   176

   177

    # Method called when dragging with a box edited

   178

    def OnMotion(self, event, scaling):

   179

        pos = GetScaledEventPosition(event, scaling)

   180

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

   181

        self.lastBox = wxRect(self.currentBox.x, self.currentBox.y, self.currentBox.width,

   182

            self.currentBox.height)

   183

        # Calculate new position and size of the box 

   184

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

   185

            self.currentBox.x = self.startPoint.x

   186

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

   187

        else:

   188

            self.currentBox.x = pos.x

   189

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

   190

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

   191

            self.currentBox.y = self.startPoint.y

   192

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

   193

        else:

   194

            self.currentBox.y = pos.y

   195

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

   196

        self.Redraw()

   197

   198

    # Method called when dragging is stopped

   199

    def OnLeftUp(self, event, scaling):

   200

        self.drawingSurface.SetCursor(wxNullCursor)

   201

        self.lastBox = self.currentBox

   202

        self.currentBox = None

   203

        self.Redraw()

   204

   205

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

   206

    def Redraw(self):

   207

        dc = wxClientDC(self.drawingSurface)

   208

        dc.SetPen(wxPen(wxWHITE, 1, wxDOT))

   209

        dc.SetBrush(wxTRANSPARENT_BRUSH)

   210

        dc.SetLogicalFunction(wxXOR)

   211

        if self.lastBox:

   212

            # Erase last box

   213

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

   214

                self.lastBox.height)

   215

        if self.currentBox:

   216

            # Draw current box

   217

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

   218

                self.currentBox.height)

   219

   220

   221

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

   222

#                           Graphic element base class

   223

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

   224

   225

"""

   226

Class that implements a generic graphic element

   227

"""

   228

   229

class Graphic_Element:

   230

   231

    # Create a new graphic element

   232

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

   233

        self.Parent = parent

   234

        self.Id = id

   235

        self.oldPos = None

   236

        self.Handle = False

   237

        self.Dragging = False

   238

        self.Selected = False

   239

        self.Pos = wxPoint(0, 0)

   240

        self.Size = wxSize(0, 0)

   241

        self.BoundingBox = wxRect(0, 0, 0, 0)

   242

   243

    # Make a clone of this element

   244

    def Clone(self):

   245

        return Graphic_Element(self.Parent, self.Id)

   246

   247

    # Changes the block position

   248

    def SetPosition(self, x, y):

   249

        self.Pos.x = x

   250

        self.Pos.y = y

   251

        self.RefreshConnected()

   252

        self.RefreshBoundingBox()

   253

   254

    # Returns the block position

   255

    def GetPosition(self):

   256

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

   257

   258

    # Changes the element size

   259

    def SetSize(self, width, height):

   260

        self.Size.SetWidth(width)

   261

        self.Size.SetHeight(height)

   262

        self.RefreshConnectors()

   263

        self.RefreshBoundingBox()

   264

   265

    # Returns the element size

   266

    def GetSize(self):

   267

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

   268

   269

    # Refresh the element Bounding Box

   270

    def RefreshBoundingBox(self):

   271

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

   272

   273

    # Refresh the element connectors position

   274

    def RefreshConnectors(self):

   275

        pass

   276

   277

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

   278

    def RefreshConnected(self):

   279

        pass

   280

   281

    # Change the parent

   282

    def SetParent(self, parent):

   283

        self.Parent = parent

   284

   285

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

   286

    def Delete(self):

   287

        pass

   288

   289

    # Returns the Id

   290

    def GetId(self):

   291

        return self.Id

   292

   293

    # Returns if the point given is in the bounding box

   294

    def HitTest(self, pt):

   295

        rect = self.BoundingBox

   296

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

   297

   298

    # Override this method for refreshing the bounding box

   299

    def RefreshBoundingBox(self):

   300

        pass

   301

   302

    # Returns the bounding box

   303

    def GetBoundingBox(self):

   304

        return self.BoundingBox

   305

   306

    # Change the variable that indicates if this element is selected

   307

    def SetSelected(self, selected):

   308

        self.Selected = selected

   309

   310

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

   311

    def TestHandle(self, pt):

   312

        # Verify that this element is selected

   313

        if self.Selected:

   314

            # Find if point is on a handle horizontally

   315

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

   316

                handle_x = 1

   317

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

   318

                handle_x = 2

   319

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

   320

                handle_x = 3

   321

            else:

   322

                handle_x = 0

   323

            # Find if point is on a handle vertically

   324

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

   325

                handle_y = 1

   326

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

   327

                handle_y = 2

   328

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

   329

                handle_y = 3

   330

            else:

   331

                handle_y = 0

   332

            # Verify that the result is valid

   333

            if (handle_x, handle_y) in VALID_HANDLES:

   334

                return handle_x, handle_y

   335

        return 0, 0

   336

   337

    # Method called when a LeftDown event have been generated

   338

    def OnLeftDown(self, event, scaling):

   339

        pos = event.GetPosition()

   340

        # Test if an handle have been clicked

   341

        result = self.TestHandle(pos)

   342

        # Find which type of handle have been clicked,

   343

        # Save a resize event and change the cursor

   344

        if result == (1, 1) or result == (3, 3):

   345

            self.Handle = (HANDLE_RESIZE, result)

   346

            self.Parent.SetCursor(wxStockCursor(wxCURSOR_SIZENWSE))

   347

        elif result == (1, 3) or result == (3, 1):

   348

            self.Handle = (HANDLE_RESIZE, result)

   349

            self.Parent.SetCursor(wxStockCursor(wxCURSOR_SIZENESW))

   350

        elif result == (1, 2) or result == (3, 2):

   351

            self.Handle = (HANDLE_RESIZE, result)

   352

            self.Parent.SetCursor(wxStockCursor(wxCURSOR_SIZEWE))

   353

        elif result == (2, 1) or result == (2, 3):

   354

            self.Handle = (HANDLE_RESIZE, result)

   355

            self.Parent.SetCursor(wxStockCursor(wxCURSOR_SIZENS))

   356

        # If no handle have been clicked, save a move event, and change the cursor

   357

        else:

   358

            self.Handle = (HANDLE_MOVE, None)

   359

            self.Parent.SetCursor(wxStockCursor(wxCURSOR_HAND))

   360

            self.SetSelected(False)

   361

        # Initializes the last position

   362

        self.oldPos = GetScaledEventPosition(event, scaling)

   363

   364

    # Method called when a LeftUp event have been generated

   365

    def OnLeftUp(self, event, scaling):

   366

        # If a dragging have been initiated

   367

        if self.Dragging and self.oldPos:

   368

            # Calculate the movement of cursor and refreshes the element state

   369

            pos = GetScaledEventPosition(event, scaling)

   370

            movex = pos.x - self.oldPos.x

   371

            movey = pos.y - self.oldPos.y

   372

            self.ProcessDragging(movex, movey)

   373

            self.RefreshModel()

   374

        self.SetSelected(True)

   375

        self.oldPos = None

   376

   377

    # Method called when a RightUp event have been generated

   378

    def OnRightUp(self, event, scaling):

   379

        self.SetSelected(True)

   380

        self.oldPos = None

   381

   382

    # Method called when a LeftDClick event have been generated

   383

    def OnLeftDClick(self, event, scaling):

   384

        pass

   385

   386

    # Method called when a Motion event have been generated

   387

    def OnMotion(self, event, scaling):

   388

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

   389

        if event.Dragging() and self.oldPos:

   390

            # Calculate the movement of cursor

   391

            pos = GetScaledEventPosition(event, scaling)

   392

            movex = pos.x - self.oldPos.x

   393

            movey = pos.y - self.oldPos.y

   394

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

   395

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

   396

                self.Dragging = True

   397

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

   398

            if self.Dragging:

   399

                self.ProcessDragging(movex, movey)

   400

                self.oldPos = pos

   401

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

   402

        else:

   403

            pos = event.GetPosition()

   404

            handle = self.TestHandle(pos)

   405

            if handle == (1, 1) or handle == (3, 3):

   406

                wxCallAfter(self.Parent.SetCursor, wxStockCursor(wxCURSOR_SIZENWSE))

   407

            elif handle == (1, 3) or handle == (3, 1):

   408

                wxCallAfter(self.Parent.SetCursor, wxStockCursor(wxCURSOR_SIZENESW))

   409

            elif handle == (1, 2) or handle == (3, 2):

   410

                wxCallAfter(self.Parent.SetCursor, wxStockCursor(wxCURSOR_SIZEWE))

   411

            elif handle == (2, 1) or handle == (2, 3):

   412

                wxCallAfter(self.Parent.SetCursor, wxStockCursor(wxCURSOR_SIZENS))

   413

            else:

   414

                wxCallAfter(self.Parent.SetCursor, wxNullCursor)

   415

   416

    # Moves the element

   417

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

   418

        self.Pos.x += dx

   419

        self.Pos.y += dy

   420

        self.RefreshConnected(exclude)

   421

        self.RefreshBoundingBox()

   422

   423

    # Resizes the element from position and size given

   424

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

   425

        self.Move(x, y)

   426

        self.SetSize(width, height)

   427

   428

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

   429

    def ProcessDragging(self, movex, movey):

   430

        handle_type, handle = self.Handle

   431

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

   432

        if handle_type == HANDLE_RESIZE:

   433

            x, y = 0, 0

   434

            width, height = self.GetSize()

   435

            if handle[0] == 1:

   436

                x = movex

   437

                width -= movex

   438

            elif handle[0] == 3:

   439

                width += movex

   440

            if handle[1] == 1:

   441

                y = movey

   442

                height -= movey

   443

            elif handle[1] == 3:

   444

                height += movey

   445

            # Verify that new size is not lesser than minimum

   446

            min_width, min_height = self.GetMinSize()

   447

            if width >= min_width and height >= min_height:

   448

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

   449

        # If it is a move handle, Move this element

   450

        elif handle_type == HANDLE_MOVE:

   451

            self.Move(movex, movey)

   452

   453

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

   454

    def RefreshModel(self, move=True):

   455

        pass

   456

   457

    # Draws the handles of this element if it is selected

   458

    def Draw(self, dc):

   459

        if self.Selected:

   460

            dc.SetPen(wxBLACK_PEN)

   461

            dc.SetBrush(wxBLACK_BRUSH)

   462

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

   463

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

   464

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

   465

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

   466

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

   467

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

   468

                self.BoundingBox.y + (self.BoundingBox.height - HANDLE_SIZE) / 2, HANDLE_SIZE, HANDLE_SIZE)

   469

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

   470

                self.BoundingBox.y + self.BoundingBox.height + 2, HANDLE_SIZE, HANDLE_SIZE)

   471

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

   472

                self.BoundingBox.y + self.BoundingBox.height + 2, HANDLE_SIZE, HANDLE_SIZE)

   473

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

   474

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

   475

            dc.SetBrush(wxWHITE_BRUSH)

   476

   477

   478

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

   479

#                           Group of graphic elements

   480

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

   481

   482

"""

   483

Class that implements a group of graphic elements

   484

"""

   485

   486

class Graphic_Group(Graphic_Element):

   487

   488

    # Create a new group of graphic elements

   489

    def __init__(self, parent):

   490

        Graphic_Element.__init__(self, parent)

   491

        self.Elements = []

   492

        self.RefreshBoundingBox()

   493

   494

    # Destructor

   495

    def __del__(self):

   496

        self.Elements = []

   497

   498

    # Make a clone of this group

   499

    def Clone(self):

   500

        clone = Graphic_Group(self.Parent)

   501

        elements = []

   502

        # Makes a clone of all the elements in this group

   503

        for element in self.Elements:

   504

            elements.append(element.Clone())

   505

        clone.SetElements(elements)

   506

        return clone

   507

   508

    # Clean this group of elements

   509

    def Clean(self):

   510

        # Clean all the elements of the group

   511

        for element in self.Elements:

   512

            element.Clean()

   513

   514

    # Delete this group of elements

   515

    def Delete(self):

   516

        # Delete all the elements of the group

   517

        for element in self.Elements:

   518

            element.Delete()

   519

   520

    # Returns if the point given is in the bounding box of one of the elements of this group

   521

    def HitTest(self, pt):

   522

        result = False

   523

        for element in self.Elements:

   524

            result |= element.HitTest(pt)

   525

        return result

   526

   527

    # Returns if the element given is in this group

   528

    def IsElementIn(self, element):

   529

        return element in self.Elements

   530