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

from types import TupleType

    26

from time import time as gettime

    27

import math

    28

import numpy

    29

    30

import wx

    31

import wx.lib.buttons

    32

    33

import matplotlib

    34

matplotlib.use('WX')

    35

import matplotlib.pyplot

    36

from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    37

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    38

from matplotlib.backends.backend_agg import FigureCanvasAgg

    39

from mpl_toolkits.mplot3d import Axes3D

    40

color_cycle = ['r', 'b', 'g', 'm', 'y', 'k']

    41

cursor_color = '#800080'

    42

    43

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    44

from dialogs.ForceVariableDialog import ForceVariableDialog

    45

from util.BitmapLibrary import GetBitmap

    46

    50

class DebugVariableDropTarget(wx.TextDropTarget):

    51

    52

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

    53

        wx.TextDropTarget.__init__(self)

    54

        self.ParentWindow = parent

    55

        self.ParentControl = control

    56

    57

    def __del__(self):

    58

        self.ParentWindow = None

    59

        self.ParentControl = None

    60

    61

    def OnDragOver(self, x, y, d):

    62

        if self.ParentControl is not None:

    63

            self.ParentControl.OnMouseDragging(x, y)

    64

        else:

    65

            self.ParentWindow.RefreshHighlight(x, y)

    66

        return wx.TextDropTarget.OnDragOver(self, x, y, d)

    67

    68

    def OnDropText(self, x, y, data):

    69

        message = None

    70

        try:

    71

            values = eval(data)

    72

        except:

    73

            message = _("Invalid value \"%s\" for debug variable")%data

    74

            values = None

    75

        if not isinstance(values, TupleType):

    76

            message = _("Invalid value \"%s\" for debug variable")%data

    77

            values = None

    78

    79

        if message is not None:

    80

            wx.CallAfter(self.ShowMessage, message)

    81

        elif values is not None and values[1] == "debug":

    82

            if self.ParentControl is not None:

    83

                width, height = self.ParentControl.GetSize()

    84

                target_idx = self.ParentControl.GetIndex()

    85

                merge_type = GRAPH_PARALLEL

    86

                if isinstance(self.ParentControl, DebugVariableGraphic):

    87

                    if self.ParentControl.Is3DCanvas():

    88

                        if y > height / 2:

    89

                            target_idx += 1

    90

                        if len(values) > 1 and values[2] == "move":

    91

                            self.ParentWindow.MoveValue(values[0], target_idx)

    92

                        else:

    93

                            self.ParentWindow.InsertValue(values[0], target_idx, force=True)

    94

    95

                    else:

    96

                        rect = self.ParentControl.GetAxesBoundingBox()

    97

                        if rect.InsideXY(x, y):

    98

                            merge_rect = wx.Rect(rect.x, rect.y, rect.width / 2., rect.height)

    99

                            if merge_rect.InsideXY(x, y):

   100

                                merge_type = GRAPH_ORTHOGONAL

   101

                            wx.CallAfter(self.ParentWindow.MergeGraphs, values[0], target_idx, merge_type, force=True)

   102

                        else:

   103

                            if y > height / 2:

   104

                                target_idx += 1

   105

                            if len(values) > 2 and values[2] == "move":

   106

                                self.ParentWindow.MoveValue(values[0], target_idx)

   107

                            else:

   108

                                self.ParentWindow.InsertValue(values[0], target_idx, force=True)

   109

                else:

   110

                    if y > height / 2:

   111

                        target_idx += 1

   112

                    if len(values) > 2 and values[2] == "move":

   113

                        self.ParentWindow.MoveValue(values[0], target_idx)

   114

                    else:

   115

                        self.ParentWindow.InsertValue(values[0], target_idx, force=True)

   116

   117

            elif len(values) > 2 and values[2] == "move":

   118

                self.ParentWindow.MoveValue(values[0])

   119

            else:

   120

                self.ParentWindow.InsertValue(values[0], force=True)

   121

   122

    def OnLeave(self):

   123

        self.ParentWindow.ResetHighlight()

   124

        return wx.TextDropTarget.OnLeave(self)

   125

   126

    def ShowMessage(self, message):

   127

        dialog = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   128

        dialog.ShowModal()

   129

        dialog.Destroy()

   130

   131

MILLISECOND = 1000000

   132

SECOND = 1000 * MILLISECOND

   133

MINUTE = 60 * SECOND

   134

HOUR = 60 * MINUTE

   135

DAY = 24 * HOUR

   136

   137

ZOOM_VALUES = map(lambda x:("x %.1f" % x, x), [math.sqrt(2) ** i for i in xrange(8)])

   138

RANGE_VALUES = \

   139

    [("%dms" % i, i * MILLISECOND) for i in (10, 20, 50, 100, 200, 500)] + \

   140

    [("%ds" % i, i * SECOND) for i in (1, 2, 5, 10, 20, 30)] + \

   141

    [("%dm" % i, i * MINUTE) for i in (1, 2, 5, 10, 20, 30)] + \

   142

    [("%dh" % i, i * HOUR) for i in (1, 2, 3, 6, 12, 24)]

   143

   144

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   145

   146

SCROLLBAR_UNIT = 10

   147

   148

#CANVAS_HIGHLIGHT_TYPES

   149

[HIGHLIGHT_NONE,

   150

 HIGHLIGHT_BEFORE,

   151

 HIGHLIGHT_AFTER,

   152

 HIGHLIGHT_LEFT,

   153

 HIGHLIGHT_RIGHT,

   154

 HIGHLIGHT_RESIZE] = range(6)

   155

   156

HIGHLIGHT_DROP_PEN = wx.Pen(wx.Colour(0, 128, 255))

   157

HIGHLIGHT_DROP_BRUSH = wx.Brush(wx.Colour(0, 128, 255, 128))

   158

HIGHLIGHT_RESIZE_PEN = wx.Pen(wx.Colour(200, 200, 200))

   159

HIGHLIGHT_RESIZE_BRUSH = wx.Brush(wx.Colour(200, 200, 200))

   160

   161

#CANVAS_SIZE_TYPES

   162

[SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI] = [0, 100, 200]

   163

   164

DEFAULT_CANVAS_HEIGHT = 200.

   165

CANVAS_BORDER = (20., 10.)

   166

CANVAS_PADDING = 8.5

   167

VALUE_LABEL_HEIGHT = 17.

   168

AXES_LABEL_HEIGHT = 12.75

   169

   170

def compute_mask(x, y):

   171

    mask = []

   172

    for xp, yp in zip(x, y):

   173

        if xp == yp:

   174

            mask.append(xp)

   175

        else:

   176

            mask.append("*")

   177

    return mask

   178

   179

def NextTick(variables):

   180

    next_tick = None

   181

    for item, data in variables:

   182

        if len(data) > 0:

   183

            if next_tick is None:

   184

                next_tick = data[0][0]

   185

            else:

   186

                next_tick = min(next_tick, data[0][0])

   187

    return next_tick

   188

   189

def OrthogonalData(item, start_tick, end_tick):

   190

    data = item.GetData(start_tick, end_tick)

   191

    min_value, max_value = item.GetValueRange()

   192

    if min_value is not None and max_value is not None:

   193

        center = (min_value + max_value) / 2.

   194

        range = max(1.0, max_value - min_value)

   195

    else:

   196

        center = 0.5

   197

        range = 1.0

   198

    return data, center - range * 0.55, center + range * 0.55

   199

   200

class DebugVariableViewer:

   201

   202

    def __init__(self, window, items=[]):

   203

        self.ParentWindow = window

   204

        self.Items = items

   205

   206

        self.Highlight = HIGHLIGHT_NONE

   207

        self.Buttons = []

   208

   209

    def __del__(self):

   210

        self.ParentWindow = None

   211

   212

    def GetIndex(self):

   213

        return self.ParentWindow.GetViewerIndex(self)

   214

   215

    def GetItem(self, variable):

   216

        for item in self.Items:

   217

            if item.GetVariable() == variable:

   218

                return item

   219

        return None

   220

   221

    def GetItems(self):

   222

        return self.Items

   223

   224

    def GetVariables(self):

   225

        if len(self.Items) > 1:

   226

            variables = [item.GetVariable() for item in self.Items]

   227

            if self.GraphType == GRAPH_ORTHOGONAL:

   228

                return tuple(variables)

   229

            return variables

   230

        return self.Items[0].GetVariable()

   231

   232

    def AddItem(self, item):

   233

        self.Items.append(item)

   234

   235

    def RemoveItem(self, item):

   236

        if item in self.Items:

   237

            self.Items.remove(item)

   238

   239

    def Clear(self):

   240

        for item in self.Items:

   241

            self.ParentWindow.RemoveDataConsumer(item)

   242

        self.Items = []

   243

   244

    def IsEmpty(self):

   245

        return len(self.Items) == 0

   246

   247

    def UnregisterObsoleteData(self):

   248

        for item in self.Items[:]:

   249

            iec_path = item.GetVariable()

   250

            if self.ParentWindow.GetDataType(iec_path) is None:

   251

                self.ParentWindow.RemoveDataConsumer(item)

   252

                self.RemoveItem(item)

   253

            else:

   254

                self.ParentWindow.AddDataConsumer(iec_path.upper(), item)

   255

                item.RefreshVariableType()

   256

   257

    def ResetData(self):

   258

        for item in self.Items:

   259

            item.ResetData()

   260

   261

    def RefreshViewer(self):

   262

        pass

   263

   264

    def SetHighlight(self, highlight):

   265

        if self.Highlight != highlight:

   266

            self.Highlight = highlight

   267

            return True

   268

        return False

   269

   270

    def GetButtons(self):

   271

        return self.Buttons

   272

   273

    def HandleButtons(self, x, y):

   274

        for button in self.GetButtons():

   275

            if button.HitTest(x, y):

   276

                button.ProcessCallback()

   277

                return True

   278

        return False

   279

   280

    def IsOverButton(self, x, y):

   281

        for button in self.GetButtons():

   282

            if button.HitTest(x, y):

   283

                return True

   284

        return False

   285

   286

    def ShowButtons(self, show):

   287

        for button in self.Buttons:

   288

            if show:

   289

                button.Show()

   290

            else:

   291

                button.Hide()

   292

        self.RefreshButtonsState()

   293

        self.ParentWindow.ForceRefresh()

   294

   295

    def RefreshButtonsState(self, refresh_positions=False):

   296

        if self:

   297

            width, height = self.GetSize()

   298

            if refresh_positions:

   299

                offset = 0

   300

                buttons = self.Buttons[:]

   301

                buttons.reverse()

   302

                for button in buttons:

   307

                self.ParentWindow.ForceRefresh()

   308

   309

    def DrawCommonElements(self, dc, buttons=None):

   310

        width, height = self.GetSize()

   311

   312

        dc.SetPen(HIGHLIGHT_DROP_PEN)

   313

        dc.SetBrush(HIGHLIGHT_DROP_BRUSH)

   314

        if self.Highlight in [HIGHLIGHT_BEFORE]:

   315

            dc.DrawLine(0, 1, width - 1, 1)

   316

        elif self.Highlight in [HIGHLIGHT_AFTER]:

   317

            dc.DrawLine(0, height - 1, width - 1, height - 1)

   318

   319

        if buttons is None:

   320

            buttons = self.Buttons

   321

        for button in buttons:

   322

            button.Draw(dc)

   323

   324

        if self.ParentWindow.IsDragging():

   325

            destBBox = self.ParentWindow.GetDraggingAxesClippingRegion(self)

   326

            srcPos = self.ParentWindow.GetDraggingAxesPosition(self)

   327

            if destBBox.width > 0 and destBBox.height > 0:

   328

                srcPanel = self.ParentWindow.DraggingAxesPanel

   329

                srcBBox = srcPanel.GetAxesBoundingBox()

   330

   331

                if destBBox.x == 0:

   332

                    srcX = srcBBox.x - srcPos.x

   333

                else:

   334

                    srcX = srcBBox.x

   335

                if destBBox.y == 0:

   336

                    srcY = srcBBox.y - srcPos.y

   337

                else:

   338

                    srcY = srcBBox.y

   339

   340

                srcBmp = _convert_agg_to_wx_bitmap(srcPanel.get_renderer(), None)

   341

                srcDC = wx.MemoryDC()

   342

                srcDC.SelectObject(srcBmp)

   343

   344

                dc.Blit(destBBox.x, destBBox.y, 

   345

                        int(destBBox.width), int(destBBox.height), 

   346

                        srcDC, srcX, srcY)

   347

   348

    def OnEnter(self, event):

   349

        self.ShowButtons(True)

   350

        event.Skip()

   351

   352

    def OnLeave(self, event):

   353

        if self.Highlight != HIGHLIGHT_RESIZE or self.CanvasStartSize is None:

   354

            x, y = event.GetPosition()

   355

            width, height = self.GetSize()

   356

            if (x <= 0 or x >= width - 1 or

   357

                y <= 0 or y >= height - 1):

   358

                self.ShowButtons(False)

   359

        event.Skip()

   360

   361

    def OnCloseButton(self):

   362

        wx.CallAfter(self.ParentWindow.DeleteValue, self)

   363

   364

    def OnForceButton(self):

   365

        wx.CallAfter(self.ForceValue, self.Items[0])

   366

   367

    def OnReleaseButton(self):

   368

        wx.CallAfter(self.ReleaseValue, self.Items[0])

   369

   370

    def OnResizeWindow(self, event):

   371

        wx.CallAfter(self.RefreshButtonsState, True)

   372

        event.Skip()

   373

   374

    def OnMouseDragging(self, x, y):

   375

        xw, yw = self.GetPosition()

   376

        self.ParentWindow.RefreshHighlight(x + xw, y + yw)

   377

   378

    def OnDragging(self, x, y):

   379

        width, height = self.GetSize()

   380

        if y < height / 2:

   381

            if self.ParentWindow.IsViewerFirst(self):

   382

                self.SetHighlight(HIGHLIGHT_BEFORE)

   383

            else:

   384

                self.SetHighlight(HIGHLIGHT_NONE)

   385

                self.ParentWindow.HighlightPreviousViewer(self)

   386

        else:

   387

            self.SetHighlight(HIGHLIGHT_AFTER)

   388

   389

    def OnEraseBackground(self, event):

   390

        pass

   391

   392

    def OnResize(self, event):

   393

        wx.CallAfter(self.RefreshButtonsState, True)

   394

        event.Skip()

   395

   396

    def ForceValue(self, item):

   397

        iec_path = item.GetVariable()

   398

        iec_type = self.ParentWindow.GetDataType(iec_path)

   399

        if iec_type is not None:

   400

            dialog = ForceVariableDialog(self, iec_type, str(item.GetValue()))

   401

            if dialog.ShowModal() == wx.ID_OK:

   402

                self.ParentWindow.ForceDataValue(iec_path.upper(), dialog.GetValue())

   403

   404

    def ReleaseValue(self, item):

   405

        iec_path = item.GetVariable().upper()

   406

        self.ParentWindow.ReleaseDataValue(iec_path)

   407

   408

   409

class DebugVariableText(DebugVariableViewer, wx.Panel):

   410

   411

    def __init__(self, parent, window, items=[]):

   412

        DebugVariableViewer.__init__(self, window, items)

   413

   414

        wx.Panel.__init__(self, parent)

   415

        self.SetBackgroundColour(wx.WHITE)

   416

        self.SetDropTarget(DebugVariableDropTarget(window, self))

   417

        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)

   418

        self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)

   419

        self.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter)

   420

        self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)

   421

        self.Bind(wx.EVT_SIZE, self.OnResize)

   422

        self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)

   423

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

   424

   425

        self.SetMinSize(wx.Size(0, 25))

   426

   431

   432

        self.ShowButtons(False)

   433

   434

    def RefreshViewer(self):

   435

        width, height = self.GetSize()

   436

        bitmap = wx.EmptyBitmap(width, height)

   437

   438

        dc = wx.BufferedDC(wx.ClientDC(self), bitmap)

   439

        dc.Clear()

   440

        dc.BeginDrawing()

   441

   442

        gc = wx.GCDC(dc)

   443

   444

        item_name = self.Items[0].GetVariable(self.ParentWindow.GetVariableNameMask())

   445

        w, h = gc.GetTextExtent(item_name)

   446

        gc.DrawText(item_name, 20, (height - h) / 2)

   447

   448

        if self.Items[0].IsForced():

   449

            gc.SetTextForeground(wx.BLUE)

   450

            self.Buttons[0].Disable()

   451

            self.Buttons[1].Enable()

   452

        else:

   453

            self.Buttons[1].Disable()

   454

            self.Buttons[0].Enable()

   455

        self.RefreshButtonsState(True)

   456

   457

        item_value = self.Items[0].GetValue()

   458

        w, h = gc.GetTextExtent(item_value)

   459

        gc.DrawText(item_value, width - 40 - w, (height - h) / 2)

   460

   461

        self.DrawCommonElements(gc)

   462

   463

        gc.EndDrawing()

   464

   465

    def OnLeftDown(self, event):

   466

        width, height = self.GetSize()

   467

        item_name = self.Items[0].GetVariable(self.ParentWindow.GetVariableNameMask())

   468

        w, h = self.GetTextExtent(item_name)

   469

        x, y = event.GetPosition()

   470

        rect = wx.Rect(20, (height - h) / 2, w, h)

   471

        if rect.InsideXY(x, y):

   472

            data = wx.TextDataObject(str((self.Items[0].GetVariable(), "debug", "move")))

   473

            dragSource = wx.DropSource(self)

   474

            dragSource.SetData(data)

   475

            dragSource.DoDragDrop()

   476

        else:

   477

            event.Skip()

   478

   479

    def OnLeftUp(self, event):

   480

        x, y = event.GetPosition()

   481

        wx.CallAfter(self.HandleButtons, x, y)

   482

        event.Skip()

   483

   484

    def OnPaint(self, event):

   485

        self.RefreshViewer()

   486

        event.Skip()

   487

   488

class DebugVariableGraphic(DebugVariableViewer, FigureCanvas):

   489

   490

    def __init__(self, parent, window, items, graph_type):

   491

        DebugVariableViewer.__init__(self, window, items)

   492

   493

        self.CanvasSize = SIZE_MINI

   494

        self.GraphType = graph_type

   495

        self.CursorTick = None

   496

        self.MouseStartPos = None