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

from types import *

    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_POWERRAIL_WIDTH = 3                  # Width of a Powerrail

    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 = 40      # 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, COIL_RISING, COIL_FALLING] = range(6)

    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, 

    83

 MODE_COIL, MODE_CONTACT, MODE_POWERRAIL, MODE_INITIALSTEP, MODE_STEP, 

    84

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

    85

    86

# Contants for defining alignment types for graphic group 

    87

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

    88

    89

# Contants for defining which drawing mode is selected for app

    90

[FREEDRAWING_MODE, DRIVENDRAWING_MODE] = [1, 2]

    91

    92

# Color for Highlighting

    93

HIGHLIGHTCOLOR = wx.CYAN

    94

    95

CURSORS = None

    96

    97

def ResetCursors():

    98

    global CURSORS

    99

    if CURSORS == None:

   100

        CURSORS = [wx.NullCursor, 

   101

                   wx.StockCursor(wx.CURSOR_HAND),

   102

                   wx.StockCursor(wx.CURSOR_SIZENWSE),

   103

                   wx.StockCursor(wx.CURSOR_SIZENESW),

   104

                   wx.StockCursor(wx.CURSOR_SIZEWE),

   105

                   wx.StockCursor(wx.CURSOR_SIZENS)]

   106

   107

HANDLE_CURSORS = {

   108

    (1, 1) : 2,

   109

    (3, 3) : 2,

   110

    (1, 3) : 3,

   111

    (3, 1) : 3,

   112

    (1, 2) : 4,

   113

    (3, 2) : 4,

   114

    (2, 1) : 5,

   115

    (2, 3) : 5

   116

}

   117

   118

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

   119

    fraction = float(x) / float(n)

   120

    if constraint == - 1:

   121

        xround = int(fraction)

   122

    else:

   123

        xround = round(fraction)

   124

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

   125

            xround += 1

   126

    return xround * n

   127

   128

"""

   129

Basic vector operations for calculate wire points

   130

"""

   131

   132

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

   133

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

   134

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

   135

    if normal:

   136

        return normalize(vector)

   137

    return vector

   138

   139

# Calculate the norm of a given vector

   140

def norm(v):

   141

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

   142

   143

# Normalize a given vector

   144

def normalize(v):

   145

    v_norm = norm(v)

   146

    # Verifie if it is not a null vector

   147

    if v_norm > 0:

   148

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

   149

    else:

   150

        return v

   151

   152

# Calculate the scalar product of two vectors

   153

def is_null_vector(v):

   154

    return v == (0, 0)

   155

   156

# Calculate the scalar product of two vectors

   157

def add_vectors(v1, v2):

   158

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

   159

   160

# Calculate the scalar product of two vectors

   161

def product(v1, v2):

   162

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

   163

   164

   165

"""

   166

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

   167

"""

   168

   169

def GetScaledEventPosition(event, dc, scaling):

   170

    pos = event.GetLogicalPosition(dc)

   171

    if scaling:

   172

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

   173

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

   174

    return pos

   175

   176

   177

"""

   178

Function that choose a direction during the wire points generation

   179

"""

   180

   181

def DirectionChoice(v_base, v_target, dir_target):

   182

    dir_product = product(v_base, v_target)

   183

    if dir_product < 0:

   184

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

   185

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

   186

        return dir_target

   187

    return v_base

   188

   189

   190

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

   191

#                               Viewer Rubberband

   192

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

   193

   194

"""

   195

Class that implements a rubberband

   196

"""

   197

   198

class RubberBand:

   199

   200

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

   201

    def __init__(self, drawingSurface):

   202

        self.drawingSurface = drawingSurface

   203

        self.Reset()

   204

   205

    # Method that initializes the internal attributes of the rubberband

   206

    def Reset(self):

   207

        self.startPoint = None

   208

        self.currentBox = None

   209

        self.lastBox = None

   210

   211

    # Method that return if a box is currently edited

   212

    def IsShown(self):

   213

        return self.currentBox != None

   214

   215

    # Method that returns the currently edited box

   216

    def GetCurrentExtent(self):

   217

        return self.currentBox

   218

   219

    # Method called when a new box starts to be edited

   220

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

   221

        pos = GetScaledEventPosition(event, dc, scaling)

   222

        # Save the point for calculate the box position and size

   223

        self.startPoint = pos

   224

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

   225

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

   226

        self.Redraw()

   227

   228

    # Method called when dragging with a box edited

   229

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

   230

        pos = GetScaledEventPosition(event, dc, scaling)

   231

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

   232

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

   233

            self.currentBox.height)

   234

        # Calculate new position and size of the box 

   235

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

   236

            self.currentBox.x = self.startPoint.x

   237

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

   238

        else:

   239

            self.currentBox.x = pos.x

   240

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

   241

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

   242

            self.currentBox.y = self.startPoint.y

   243

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

   244

        else:

   245

            self.currentBox.y = pos.y

   246

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

   247

        self.Redraw()

   248

   249

    # Method called when dragging is stopped

   250

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

   251

        self.drawingSurface.SetCursor(wx.NullCursor)

   252

        self.lastBox = self.currentBox

   253

        self.currentBox = None

   254

        self.Redraw()

   255

   256

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

   257

    def Redraw(self, dc = None):

   258

        if not dc:

   259

            dc = self.drawingSurface.GetLogicalDC()

   260

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

   261

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   262

        dc.SetLogicalFunction(wx.XOR)

   263

        if self.lastBox:

   264

            # Erase last box

   265

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

   266

                self.lastBox.height)

   267

        if self.currentBox:

   268

            # Draw current box

   269

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

   270

                self.currentBox.height)

   271

   272

    # Erase last box

   273

    def Erase(self, dc = None):

   274

        if not dc:

   275

            dc = self.drawingSurface.GetLogicalDC()

   276

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

   277

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   278

        dc.SetLogicalFunction(wx.XOR)

   279

        if self.lastBox:

   280

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

   281

                self.lastBox.height)

   282

   283

    # Draw current box

   284

    def Draw(self, dc = None):

   285

        if not dc:

   286

            dc = self.drawingSurface.GetLogicalDC()

   287

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

   288

        dc.SetBrush(wx.TRANSPARENT_BRUSH)

   289

        dc.SetLogicalFunction(wx.XOR)

   290

        if self.currentBox:

   291

            # Draw current box

   292

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

   293

                self.currentBox.height)

   294

   295

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

   296

#                               Viewer Rubberband

   297

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

   298

   299

"""

   300

Class that implements a custom tool tip

   301

"""

   302

   303

class ToolTip(wx.PopupWindow):

   304

   305

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

   306

    def __init__(self, parent, tip):

   307

        wx.PopupWindow.__init__(self, parent)

   309

        self.SetTip(tip)

   310

   311

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

   312

   313

    def SetTip(self, tip):

   314

        self.Tip = tip

   315

        dc = wx.ClientDC(self)

   316

        w, h = dc.GetTextExtent(tip)

   317

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

   318

        self.Refresh()

   319

   320

    def OnPaint(self, event):

   321

        dc = wx.AutoBufferedPaintDC(self)

   322

        dc.Clear()

   323

        dc.SetPen(wx.BLACK_PEN)

   324

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

   325

        dc.BeginDrawing()

   326

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

   327

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

   328

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

   329

        dc.EndDrawing()

   330

        event.Skip()

   331

   332

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

   333

#                    Helper for highlighting error in drawn text

   334

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

   335

   336

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

   337

    dc.SetPen(wx.TRANSPARENT_PEN)

   338

    dc.SetLogicalFunction(wx.AND)

   339

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

   340

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

   341

    dc.SetLogicalFunction(wx.XOR)

   342

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

   343

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

   344

    dc.SetLogicalFunction(wx.COPY)

   345

   346

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

   347

#                           Graphic element base class

   348

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

   349

   350

"""

   351

Class that implements a generic graphic element

   352

"""

   353

   354

class Graphic_Element:

   355

   356

    # Create a new graphic element

   357

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

   358

        self.Parent = parent

   359

        self.Id = id

   360

        self.oldPos = None

   361

        self.StartPos = None

   362

        self.CurrentDrag = None

   363

        self.Handle = (None,None)

   364

        self.Dragging = False

   365

        self.Selected = False

   366

        self.Highlighted = False

   367

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

   368

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

   369

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

   370

        self.Visible = False

   371

        self.CurrentCursor = 0

   372

        ResetCursors()

   373

   374

    def TestVisible(self, screen):

   375

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

   376

   377

    def IsVisible(self):

   378

        return self.Visible

   379

   380

    def SpreadCurrent(self):

   381

        pass

   382

   383

    def GetConnectorTranslation(self, element):

   384

        return {}

   385

   386

    def IsOfType(self, type, reference):

   387

        return self.Parent.IsOfType(type, reference)

   388

   389

    def IsEndType(self, type):

   390

        return self.Parent.IsEndType(type)

   391

   392

    def GetDragging(self):

   393

        return self.Dragging

   394

   395

    # Make a clone of this element

   396

    def Clone(self, parent):

   397

        return Graphic_Element(parent, self.Id)

   398

   399

    # Changes the block position

   400

    def SetPosition(self, x, y):

   401

        self.Pos.x = x

   402

        self.Pos.y = y

   403

        self.RefreshConnected()

   404

        self.RefreshBoundingBox()

   405

   406

    # Returns the block position

   407

    def GetPosition(self):

   408

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

   409

   410

    # Changes the element size

   411

    def SetSize(self, width, height):

   412

        self.Size.SetWidth(width)

   413

        self.Size.SetHeight(height)

   414

        self.RefreshConnectors()

   415

        self.RefreshBoundingBox()

   416

   417

    # Returns the element size

   418

    def GetSize(self):

   419

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

   420

   421

    # Returns the minimum element size

   422

    def GetMinSize(self):

   423

        return 0, 0

   424

   425

    # Refresh the element Bounding Box

   426

    def RefreshBoundingBox(self):

   427

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

   428

   429

    # Refresh the element connectors position

   430

    def RefreshConnectors(self):

   431

        pass

   432

   433

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

   434

    def RefreshConnected(self):

   435

        pass

   436

   437

    # Change the parent

   438

    def SetParent(self, parent):

   439

        self.Parent = parent

   440

   441

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

   442

    def Delete(self):

   443

        pass

   444

   445

    # Returns the Id

   446

    def GetId(self):

   447

        return self.Id

   448

   449

    # Returns if the point given is in the bounding box

   450

    def HitTest(self, pt):

   451

        rect = self.BoundingBox

   452

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

   453

   454

    # Returns if the point given is in the bounding box

   455

    def IsInSelection(self, rect):

   456

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

   457

   458

    # Override this method for refreshing the bounding box

   459

    def RefreshBoundingBox(self):

   460

        pass

   461

   462

    # Returns the bounding box

   463

    def GetBoundingBox(self):

   464

        return self.BoundingBox

   465

   466

    # Returns the RedrawRect

   467

    def GetRedrawRect(self, movex = 0, movey = 0):

   468

        rect = wx.Rect()

   469

        rect.x = self.BoundingBox.x - HANDLE_SIZE - 2 - abs(movex)

   470

        rect.y = self.BoundingBox.y - HANDLE_SIZE - 2 - abs(movey)

   471

        rect.width = self.BoundingBox.width + 2 * (HANDLE_SIZE + abs(movex)) + 4

   472

        rect.height = self.BoundingBox.height + 2 * (HANDLE_SIZE + abs(movey)) + 4

   473

        return rect

   474

   475

    def Refresh(self, rect = None):

   476

        if self.Visible:

   477

            if rect is not None:

   478

                self.Parent.RefreshRect(self.Parent.GetScrolledRect(rect), False)

   479

            else:

   480

                self.Parent.RefreshRect(self.Parent.GetScrolledRect(self.GetRedrawRect()), False)

   481

   482

    # Change the variable that indicates if this element is selected

   483

    def SetSelected(self, selected):

   484

        self.Selected = selected

   485

        self.Refresh()

   486

   487

    # Change the variable that indicates if this element is highlighted

   488

    def SetHighlighted(self, highlighted):

   489

        self.Highlighted = highlighted

   490

        self.Refresh()

   491

   492

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

   493

    def TestHandle(self, pt):

   494

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

   495

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

   496

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

   497

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

   498

        # Verify that this element is selected

   499

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

   500

            # Find if point is on a handle horizontally

   501

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

   502

                handle_x = 1

   503

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

   504

                handle_x = 2

   505

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

   506

                handle_x = 3