1

#!/usr/bin/env python

     2

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

     3

     6

#

     8

#

    10

#

    15

#

    20

#

    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

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 xround < fraction:

   125

            xround += 1 

   126

    return int(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

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

   190

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

   191

    pen.SetJoin(wx.JOIN_MITER)

   192

    pen.SetCap(wx.CAP_PROJECTING)

   193

    return pen

   194

   195

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

   196

#                    Helpers for highlighting text

   197

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

   198

   199

def AddHighlight(highlights, infos):

   200

    RemoveHighlight(highlights, infos)

   201

    highlights.append(infos)

   202

   203

def RemoveHighlight(highlights, infos):

   204

    if infos in highlights:

   205

        highlights.remove(infos)

   206

        return True

   207

    return False

   208

   209

def ClearHighlight(highlights, highlight_type=None):

   210

    if highlight_type is not None:

   211

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

   212

    return []

   213

   214

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

   215

    current_pen = dc.GetPen()

   216

    dc.SetPen(wx.TRANSPARENT_PEN)

   217

    for start, end, highlight_type in highlights:

   218

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

   219

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

   220

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

   221

        part_width, part_height = dc.GetTextExtent(part)

   222

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

   223

        dc.SetTextForeground(highlight_type[1])

   224

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

   225

    dc.SetPen(current_pen)

   226

    dc.SetTextForeground(wx.BLACK)

   227

   228

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

   229

#                           Graphic element base class

   230

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

   231

   232

"""

   233

Class that implements a generic graphic element

   234

"""

   235

   236

class Graphic_Element(ToolTipProducer):

   237

   238

    # Create a new graphic element

   239

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

   240

        ToolTipProducer.__init__(self, parent)

   241

        self.Parent = parent

   242

        self.Id = id

   243

        self.oldPos = None

   244

        self.StartPos = None

   245

        self.CurrentDrag = None

   246

        self.Handle = (None,None)

   247

        self.Dragging = False

   248

        self.Selected = False

   249

        self.Highlighted = False

   250

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

   251

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

   252

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

   253

        self.Visible = False

   254

   255

    def GetDefinition(self):

   256

        return [self.Id], []

   257

   258

    def TestVisible(self, screen):

   259

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

   260

   261

    def IsVisible(self):

   262

        return self.Visible

   263

   264

    def SpreadCurrent(self):

   265

        pass

   266

   267

    def GetConnectorTranslation(self, element):

   268

        return {}

   269

   270

    def FindNearestConnector(self, position, connectors):

   271

        distances = []

   272

        for connector in connectors:

   273

            connector_pos = connector.GetRelPosition()

   274

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

   275

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

   276

                              connector))

   277

        distances.sort()

   278

        if len(distances) > 0:

   279

            return distances[0][1]

   280

        return None

   281

   282

    def IsOfType(self, type, reference):

   283

        return self.Parent.IsOfType(type, reference)

   284

   285

    def IsEndType(self, type):

   286

        return self.Parent.IsEndType(type)

   287

   288

    def GetDragging(self):

   289

        return self.Dragging

   290

   291

    # Make a clone of this element

   292

    def Clone(self, parent):

   293

        return Graphic_Element(parent, self.Id)

   294

   295

    # Changes the block position

   296

    def SetPosition(self, x, y):

   297

        self.Pos.x = x

   298

        self.Pos.y = y

   299

        self.RefreshConnected()

   300

        self.RefreshBoundingBox()

   301

   302

    # Returns the block position

   303

    def GetPosition(self):

   304

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

   305

   306

    # Changes the element size

   307

    def SetSize(self, width, height):

   308

        self.Size.SetWidth(width)

   309

        self.Size.SetHeight(height)

   310

        self.RefreshConnectors()

   311

        self.RefreshBoundingBox()

   312

   313

    # Returns the element size

   314

    def GetSize(self):

   315

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

   316

   317

    # Returns the minimum element size

   318

    def GetMinSize(self):

   319

        return 0, 0

   320

   321

    # Set size of the element to the minimum size

   322

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

   323

        width, height = self.GetSize()

   324

        posx, posy = self.GetPosition()

   325

        min_width, min_height = self.GetMinSize()

   326

        if width < min_width:

   327

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

   328

            width = min_width

   329

        if height < min_height:

   330

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

   331

            height = min_height

   332

        if scaling is not None:

   333

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

   334

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

   335

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

   336

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

   337

        self.SetSize(width, height)

   338

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

   339

   340

    # Refresh the element Bounding Box

   341

    def RefreshBoundingBox(self):

   342

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

   343

   344

    # Refresh the element connectors position

   345

    def RefreshConnectors(self):

   346

        pass

   347

   348

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

   349

    def RefreshConnected(self):

   350

        pass

   351

   352

    # Change the parent

   353

    def SetParent(self, parent):

   354

        self.Parent = parent

   355

   356

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

   357

    def Delete(self):

   358

        pass

   359

   360

    # Returns the Id

   361

    def GetId(self):

   362

        return self.Id

   363

   364

    # Returns if the point given is in the bounding box

   365

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

   366

        if connectors:

   367

            rect = self.BoundingBox

   368

        else:

   369

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

   370

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

   371

   372

    # Returns if the point given is in the bounding box

   373

    def IsInSelection(self, rect):

   374

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

   375

   376

    # Override this method for refreshing the bounding box

   377

    def RefreshBoundingBox(self):

   378

        pass

   379

   380

    # Returns the bounding box

   381

    def GetBoundingBox(self):

   382

        return self.BoundingBox

   383

   384

    # Returns the RedrawRect

   385

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

   386

        scalex, scaley = self.Parent.GetViewScale()

   387

        rect = wx.Rect()

   388

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

   389

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

   390

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

   391

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

   392

        return rect

   393

   394

    def Refresh(self, rect = None):

   395

        if self.Visible:

   396

            if rect is not None:

   397

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

   398

            else:

   399

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

   400

   401

    # Change the variable that indicates if this element is selected

   402

    def SetSelected(self, selected):

   403

        self.Selected = selected

   404

        self.Refresh()

   405

   406

    # Change the variable that indicates if this element is highlighted

   407

    def SetHighlighted(self, highlighted):

   408

        self.Highlighted = highlighted

   409

        self.Refresh()

   410

   411

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

   412

    def TestHandle(self, event):

   413

        dc = self.Parent.GetLogicalDC()

   414

        scalex, scaley = dc.GetUserScale()

   415

        pos = event.GetPosition()

   416

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

   417

   418

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

   419

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

   420

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

   421

   422

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

   423

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

   424

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

   425

   426

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

   427

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

   428

   429

        # Verify that this element is selected

   430

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

   431

            # Find if point is on a handle horizontally

   432

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

   433

                handle_x = 1

   434

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

   435

                handle_x = 2

   436

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

   437

                handle_x = 3

   438

            else:

   439

                handle_x = 0

   440

            # Find if point is on a handle vertically

   441

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

   442

                handle_y = 1

   443

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

   444

                handle_y = 2

   445

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

   446

                handle_y = 3

   447

            else:

   448

                handle_y = 0

   449

            # Verify that the result is valid

   450

            if (handle_x, handle_y) in VALID_HANDLES:

   451

                return handle_x, handle_y

   452

        return 0, 0

   453

   454

    # Method called when a LeftDown event have been generated

   455

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

   456

        pos = event.GetLogicalPosition(dc)

   457

        # Test if an handle have been clicked

   458

        handle = self.TestHandle(event)

   459

        # Find which type of handle have been clicked,

   460

        # Save a resize event and change the cursor

   461

        cursor = HANDLE_CURSORS.get(handle, 1)

   462

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

   463

        if cursor > 1:

   464

            self.Handle = (HANDLE_RESIZE, handle)

   465

        else:

   466

            self.Handle = (HANDLE_MOVE, None)

   467

            self.SetSelected(False)

   468

        # Initializes the last position

   469

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

   470

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

   471

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

   472

   473

    # Method called when a LeftUp event have been generated

   474

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

   475

        # If a dragging have been initiated

   476

        if self.Dragging and self.oldPos:

   477

            self.RefreshModel()

   478

            self.Parent.RefreshBuffer()

   479

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

   480

        self.SetSelected(True)

   481

        self.oldPos = None

   482

   483

    # Method called when a RightDown event have been generated

   484

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

   485

        pass

   486

   487

    # Method called when a RightUp event have been generated

   488

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

   489

        if self.Dragging and self.oldPos:

   490

            self.RefreshModel()

   491

            self.Parent.RefreshBuffer()

   492

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

   493

        self.SetSelected(True)

   494

        self.oldPos = None

   495

        if self.Parent.Debug:

   496

            self.Parent.PopupForceMenu()

   497

   498

    # Method called when a LeftDClick event have been generated

   499

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

   500

        pass

   501

   502

    # Method called when a Motion event have been generated

   503

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

   504

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

   505

        if event.Dragging() and self.oldPos:

   506

            # Calculate the movement of cursor

   507

            pos = GetScaledEventPosition(event, dc, scaling)

   508

            movex = pos.x - self.oldPos.x

   509

            movey = pos.y - self.oldPos.y

   510

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

   511

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

   512

                self.Dragging = True

   513

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

   514

            if self.Dragging:

   515

                dragx, dragy = self.ProcessDragging(movex, movey, event, scaling)

   516

                if event.ControlDown() and self.Handle[0] == HANDLE_MOVE:

   517

                    self.oldPos.x = self.StartPos.x + self.CurrentDrag.x

   518

                    self.oldPos.y = self.StartPos.y + self.CurrentDrag.y

   519

                else:

   520

                    self.oldPos.x += dragx

   521

                    self.oldPos.y += dragy

   522

                return dragx, dragy

   523

            return movex, movey

   524

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