1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import wx

    26

from math import *

    27

from types import *

    28

import datetime

    29

from threading import Lock, Timer

    30

    31

from graphics.ToolTipProducer import ToolTipProducer

    32

from graphics.DebugDataConsumer import DebugDataConsumer

    33

    34

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

    35

#                               Common constants

    36

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

    37

    38

"""

    39

Definition of constants for dimensions of graphic elements

    40

"""

    41

    42

# FBD and SFC constants

    43

MIN_MOVE = 5                            # Minimum move before starting a element dragging

    44

CONNECTOR_SIZE = 8                      # Size of connectors

    45

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

    46

HANDLE_SIZE = 6                         # Size of the squares for handles

    47

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

    48

POINT_RADIUS = 2                        # Radius of the point of wire ends

    49

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

    50

    51

# LD constants

    52

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

    53

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

    54

LD_WIRE_SIZE = 30                       # Size of a wire between two contact

    55

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

    56

LD_POWERRAIL_WIDTH = 3                  # Width of a Powerrail

    57

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

    58

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

    59

    60

# SFC constants

    61

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

    62

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

    63

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

    64

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

    65

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

    66

SFC_WIRE_MIN_SIZE = 25                  # Size of a wire between two elements

    67

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

    68

    69

# Type definition constants for graphic elements

    70

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

    71

[CONNECTOR, CONTINUATION] = range(2)

    72

[LEFTRAIL, RIGHTRAIL] = range(2)

    73

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

    74

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

    75

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

    76

    77

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

    78

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

    79

    80

# List of value for resize handle that are valid

    81

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

    82

    83

# Contants for defining the direction of a connector

    84

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

    85

    86

# Contants for defining which mode is selected for each view

    87

[MODE_SELECTION, MODE_BLOCK, MODE_VARIABLE, MODE_CONNECTION, MODE_COMMENT,

    88

 MODE_COIL, MODE_CONTACT, MODE_POWERRAIL, MODE_INITIALSTEP, MODE_STEP,

    89

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

    90

    91

# Contants for defining alignment types for graphic group

    92

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

    93

    94

# Contants for defining which drawing mode is selected for app

    95

[FREEDRAWING_MODE, DRIVENDRAWING_MODE] = [1, 2]

    96

    97

# Color for Highlighting

    98

HIGHLIGHTCOLOR = wx.CYAN

    99

   100

# Define highlight types

   101

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

   102

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

   103

   104

# Define highlight refresh inhibition period in second

   105

REFRESH_HIGHLIGHT_PERIOD = 0.1

   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

   119

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

   120

    fraction = float(x) / float(n)

   121

    if constraint == -1:

   122

        xround = int(fraction)

   123

    else:

   124

        xround = round(fraction)

   125

        if constraint == 1 and xround < fraction:

   126

            xround += 1

   127

    return int(xround * n)

   128

   129

"""

   130

Basic vector operations for calculate wire points

   131

"""

   132

   133

   134

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

   135

    """

   136

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

   137

    """

   138

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

   139

    if normal:

   140

        return normalize(vector)

   141

    return vector

   142

   143

   144

def norm(v):

   145

    """

   146

    Calculate the norm of a given vector

   147

    """

   148

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

   149

   150

   151

def normalize(v):

   152

    """

   153

    Normalize a given vector

   154

    """

   155

    v_norm = norm(v)

   156

    # Verifie if it is not a null vector

   157

    if v_norm > 0:

   158

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

   159

    else:

   160

        return v

   161

   162

   163

def is_null_vector(v):

   164

    """

   165

    Calculate the scalar product of two vectors

   166

    """

   167

    return v == (0, 0)

   168

   169

   170

def add_vectors(v1, v2):

   171

    """

   172

    Calculate the scalar product of two vectors

   173

    """

   174

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

   175

   176

   177

def product(v1, v2):

   178

    """

   179

    Calculate the scalar product of two vectors

   180

    """

   181

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

   182

   183

   184

def GetScaledEventPosition(event, dc, scaling):

   185

    """

   186

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

   187

    """

   188

    pos = event.GetLogicalPosition(dc)

   189

    if scaling:

   190

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

   191

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

   192

    return pos

   193

   194

   195

def DirectionChoice(v_base, v_target, dir_target):

   196

    """

   197

    Function that choose a direction during the wire points generation

   198

    """

   199

    dir_product = product(v_base, v_target)

   200

    if dir_product < 0:

   201

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

   202

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

   203

        return dir_target

   204

    return v_base

   205

   206

   207

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

   208

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

   209

    pen.SetJoin(wx.JOIN_MITER)

   210

    pen.SetCap(wx.CAP_PROJECTING)

   211

    return pen

   212

   213

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

   214

#                    Helpers for highlighting text

   215

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

   216

   217

   218

def AddHighlight(highlights, infos):

   219

    RemoveHighlight(highlights, infos)

   220

    highlights.append(infos)

   221

   222

   223

def RemoveHighlight(highlights, infos):

   224

    if infos in highlights:

   225

        highlights.remove(infos)

   226

        return True

   227

    return False

   228

   229

   230

def ClearHighlight(highlights, highlight_type=None):

   231

    if highlight_type is not None:

   232

        return [highlight for highlight in highlights if highlight[2] != highlight_type]

   233

    return []

   234

   235

   236

def DrawHighlightedText(dc, text, highlights, x, y):

   237

    current_pen = dc.GetPen()

   238

    dc.SetPen(wx.TRANSPARENT_PEN)

   239

    for start, end, highlight_type in highlights:

   240

        dc.SetBrush(wx.Brush(highlight_type[0]))

   241

        offset_width, offset_height = dc.GetTextExtent(text[:start[1]])

   242

        part = text[start[1]:end[1] + 1]

   243

        part_width, part_height = dc.GetTextExtent(part)

   244

        dc.DrawRectangle(x + offset_width, y, part_width, part_height)

   245

        dc.SetTextForeground(highlight_type[1])

   246

        dc.DrawText(part, x + offset_width, y)

   247

    dc.SetPen(current_pen)

   248

    dc.SetTextForeground(wx.BLACK)

   249

   250

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

   251

#                           Graphic element base class

   252

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

   253

   254

   255

class Graphic_Element(ToolTipProducer):

   256

    """

   257

    Class that implements a generic graphic element

   258

    """

   259

   260

    # Create a new graphic element

   261

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

   262

        ToolTipProducer.__init__(self, parent)

   263

        self.Parent = parent

   264

        self.Id = id

   265

        self.oldPos = None

   266

        self.StartPos = None

   267

        self.CurrentDrag = None

   268

        self.Handle = (None, None)

   269

        self.Dragging = False

   270

        self.Selected = False

   271

        self.Highlighted = False

   272

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

   273

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

   274

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

   275

        self.Visible = False

   276

   277

    def GetDefinition(self):

   278

        return [self.Id], []

   279

   280

    def TestVisible(self, screen):

   281

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

   282

   283

    def IsVisible(self):

   284

        return self.Visible

   285

   286

    def SpreadCurrent(self):

   287

        pass

   288

   289

    def GetConnectorTranslation(self, element):

   290

        return {}

   291

   292

    def FindNearestConnector(self, position, connectors):

   293

        distances = []

   294

        for connector in connectors:

   295

            connector_pos = connector.GetRelPosition()

   296

            distances.append((sqrt((self.Pos.x + connector_pos.x - position.x) ** 2 +

   297

                                   (self.Pos.y + connector_pos.y - position.y) ** 2),

   298

                              connector))

   299

        distances.sort()

   300

        if len(distances) > 0:

   301

            return distances[0][1]

   302

        return None

   303

   304

    def IsOfType(self, type, reference):

   305

        return self.Parent.IsOfType(type, reference)

   306

   307

    def IsEndType(self, type):

   308

        return self.Parent.IsEndType(type)

   309

   310

    def GetDragging(self):

   311

        return self.Dragging

   312

   313

    # Make a clone of this element

   314

    def Clone(self, parent):

   315

        return Graphic_Element(parent, self.Id)

   316

   317

    # Changes the block position

   318

    def SetPosition(self, x, y):

   319

        self.Pos.x = x

   320

        self.Pos.y = y

   321

        self.RefreshConnected()

   322

        self.RefreshBoundingBox()

   323

   324

    # Returns the block position

   325

    def GetPosition(self):

   326

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

   327

   328

    # Changes the element size

   329

    def SetSize(self, width, height):

   330

        self.Size.SetWidth(width)

   331

        self.Size.SetHeight(height)

   332

        self.RefreshConnectors()

   333

        self.RefreshBoundingBox()

   334

   335

    # Returns the element size

   336

    def GetSize(self):

   337

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

   338

   339

    # Returns the minimum element size

   340

    def GetMinSize(self):

   341

        return 0, 0

   342

   343

    # Set size of the element to the minimum size

   344

    def SetBestSize(self, scaling, x_factor=0.5, y_factor=0.5):

   345

        width, height = self.GetSize()

   346

        posx, posy = self.GetPosition()

   347

        min_width, min_height = self.GetMinSize()

   348

        if width < min_width:

   349

            self.Pos.x = max(0, self.Pos.x - (width - min_width) * x_factor)

   350

            width = min_width

   351

        if height < min_height:

   352

            self.Pos.y = max(0, self.Pos.y - (height - min_height) * y_factor)

   353

            height = min_height

   354

        if scaling is not None:

   355

            self.Pos.x = round_scaling(self.Pos.x, scaling[0])

   356

            self.Pos.y = round_scaling(self.Pos.y, scaling[1])

   357

            width = round_scaling(width, scaling[0], 1)

   358

            height = round_scaling(height, scaling[1], 1)

   359

        self.SetSize(width, height)

   360

        return self.Pos.x - posx, self.Pos.y - posy

   361

   362

    # Refresh the element Bounding Box

   363

    def RefreshBoundingBox(self):

   364

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

   365

   366

    # Refresh the element connectors position

   367

    def RefreshConnectors(self):

   368

        pass

   369

   370

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

   371

    def RefreshConnected(self):

   372

        pass

   373

   374

    # Change the parent

   375

    def SetParent(self, parent):

   376

        self.Parent = parent

   377

   378

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

   379

    def Delete(self):

   380

        pass

   381

   382

    # Returns the Id

   383

    def GetId(self):

   384

        return self.Id

   385

   386

    # Returns if the point given is in the bounding box

   387

    def HitTest(self, pt, connectors=True):

   388

        if connectors:

   389

            rect = self.BoundingBox

   390

        else:

   391

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

   392

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

   393

   394

    # Returns if the point given is in the bounding box

   395

    def IsInSelection(self, rect):

   396

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

   397

   398

    # Override this method for refreshing the bounding box

   399

    def RefreshBoundingBox(self):

   400

        pass

   401

   402

    # Returns the bounding box

   403

    def GetBoundingBox(self):

   404

        return self.BoundingBox

   405

   406

    # Returns the RedrawRect

   407

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

   408

        scalex, scaley = self.Parent.GetViewScale()

   409

        rect = wx.Rect()

   410

        rect.x = self.BoundingBox.x - int(HANDLE_SIZE / scalex) - 3 - abs(movex)

   411

        rect.y = self.BoundingBox.y - int(HANDLE_SIZE / scaley) - 3 - abs(movey)

   412

        rect.width = self.BoundingBox.width + 2 * (int(HANDLE_SIZE / scalex) + abs(movex) + 1) + 4

   413

        rect.height = self.BoundingBox.height + 2 * (int(HANDLE_SIZE / scaley) + abs(movey) + 1) + 4

   414

        return rect

   415

   416

    def Refresh(self, rect = None):

   417

        if self.Visible:

   418

            if rect is not None:

   419

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

   420

            else:

   421

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

   422

   423

    # Change the variable that indicates if this element is selected

   424

    def SetSelected(self, selected):

   425

        self.Selected = selected

   426

        self.Refresh()

   427

   428

    # Change the variable that indicates if this element is highlighted

   429

    def SetHighlighted(self, highlighted):

   430

        self.Highlighted = highlighted

   431

        self.Refresh()

   432

   433

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

   434

    def TestHandle(self, event):

   435

        dc = self.Parent.GetLogicalDC()

   436

        scalex, scaley = dc.GetUserScale()

   437

        pos = event.GetPosition()

   438

        pt = wx.Point(*self.Parent.CalcUnscrolledPosition(pos.x, pos.y))

   439

   440

        left = (self.BoundingBox.x - 2) * scalex - HANDLE_SIZE

   441

        center = (self.BoundingBox.x + self.BoundingBox.width / 2) * scalex - HANDLE_SIZE / 2

   442

        right = (self.BoundingBox.x + self.BoundingBox.width + 2) * scalex

   443

   444

        top = (self.BoundingBox.y - 2) * scaley - HANDLE_SIZE

   445

        middle = (self.BoundingBox.y + self.BoundingBox.height / 2) * scaley - HANDLE_SIZE / 2

   446

        bottom = (self.BoundingBox.y + self.BoundingBox.height + 2) * scaley

   447

   448

        extern_rect = wx.Rect(left, top, right + HANDLE_SIZE - left, bottom + HANDLE_SIZE - top)

   449

        intern_rect = wx.Rect(left + HANDLE_SIZE, top + HANDLE_SIZE, right - left - HANDLE_SIZE, bottom - top - HANDLE_SIZE)

   450

   451

        # Verify that this element is selected

   452

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

   453

            # Find if point is on a handle horizontally

   454

            if left <= pt.x < left + HANDLE_SIZE:

   455

                handle_x = 1

   456

            elif center <= pt.x < center + HANDLE_SIZE:

   457

                handle_x = 2

   458

            elif right <= pt.x < right + HANDLE_SIZE:

   459

                handle_x = 3

   460

            else:

   461

                handle_x = 0

   462

            # Find if point is on a handle vertically

   463

            if top <= pt.y < top + HANDLE_SIZE:

   464

                handle_y = 1

   465

            elif middle <= pt.y < middle + HANDLE_SIZE:

   466

                handle_y = 2

   467

            elif bottom <= pt.y < bottom + HANDLE_SIZE:

   468

                handle_y = 3

   469

            else:

   470

                handle_y = 0

   471

            # Verify that the result is valid

   472

            if (handle_x, handle_y) in VALID_HANDLES:

   473

                return handle_x, handle_y

   474

        return 0, 0

   475

   476

    # Method called when a LeftDown event have been generated

   477

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

   478

        pos = event.GetLogicalPosition(dc)

   479

        # Test if an handle have been clicked

   480

        handle = self.TestHandle(event)

   481

        # Find which type of handle have been clicked,

   482

        # Save a resize event and change the cursor

   483

        cursor = HANDLE_CURSORS.get(handle, 1)

   484

        wx.CallAfter(self.Parent.SetCurrentCursor, cursor)

   485

        if cursor > 1:

   486

            self.Handle = (HANDLE_RESIZE, handle)

   487

        else:

   488

            self.Handle = (HANDLE_MOVE, None)

   489

            self.SetSelected(False)

   490

        # Initializes the last position

   491

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

   492

        self.StartPos = wx.Point(self.Pos.x, self.Pos.y)

   493

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

   494

   495

    # Method called when a LeftUp event have been generated

   496

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

   497

        # If a dragging have been initiated

   498

        if self.Dragging and self.oldPos:

   499

            self.RefreshModel()

   500

            self.Parent.RefreshBuffer()

   501

        wx.CallAfter(self.Parent.SetCurrentCursor, 0)

   502

        self.SetSelected(True)

   503

        self.oldPos = None

   504

   505

    # Method called when a RightDown event have been generated

   506

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

   507

        pass

   508

   509

    # Method called when a RightUp event have been generated

   510

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