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 collections import OrderedDict

    26

    27

import wx

    28

    29

import matplotlib

    30

matplotlib.use('WX')

    31

import matplotlib.pyplot

    32

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    33

    34

from dialogs.ForceVariableDialog import ForceVariableDialog

    35

    36

# Viewer highlight types

    37

[HIGHLIGHT_NONE,

    38

 HIGHLIGHT_BEFORE,

    39

 HIGHLIGHT_AFTER,

    40

 HIGHLIGHT_LEFT,

    41

 HIGHLIGHT_RIGHT,

    42

 HIGHLIGHT_RESIZE] = range(6)

    43

    44

# Viewer highlight styles

    45

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

    46

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

    47

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

    48

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

    49

    50

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

    51

#                        Base Debug Variable Viewer Class

    52

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

    53

    54

"""

    55

Class that implements a generic viewer that display a list of variable values

    56

This class has to be inherited to effectively display variable values

    57

"""

    58

    59

class DebugVariableViewer:

    60

    61

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

    62

        """

    63

        Constructor

    64

        @param window: Reference to the Debug Variable Panel

    65

        @param items: List of DebugVariableItem displayed by Viewer

    66

        """

    67

        self.ParentWindow = window

    68

        self.ItemsDict = OrderedDict([(item.GetVariable(), item)

    69

                                      for item in items])

    70

        self.Items = self.ItemsDict.viewvalues()

    71

    72

        # Variable storing current highlight displayed in Viewer

    73

        self.Highlight = HIGHLIGHT_NONE

    74

        # List of buttons

    75

        self.Buttons = []

    76

    77

    def __del__(self):

    78

        """

    79

        Destructor

    80

        """

    81

        # Remove reference to Debug Variable Panel

    82

        self.ParentWindow = None

    83

    84

    def GetIndex(self):

    85

        """

    86

        Return position of Viewer in Debug Variable Panel

    87

        @return: Position of Viewer

    88

        """

    89

        return self.ParentWindow.GetViewerIndex(self)

    90

    91

    def GetItem(self, variable):

    92

        """

    93

        Return item storing values of a variable

    94

        @param variable: Variable path

    95

        @return: Item storing values of this variable

    96

        """

    97

        return self.ItemsDict.get(variable, None)

    98

    99

    def GetItems(self):

   100

        """

   101

        Return items displayed by Viewer

   102

        @return: List of items displayed in Viewer

   103

        """

   104

        return self.ItemsDict.values()

   105

   106

    def AddItem(self, item):

   107

        """

   108

        Add an item to the list of items displayed by Viewer

   109

        @param item: Item to add to the list

   110

        """

   111

        self.ItemsDict[item.GetVariable()] = item

   112

   113

    def RemoveItem(self, item):

   114

        """

   115

        Remove an item from the list of items displayed by Viewer

   116

        @param item: Item to remove from the list

   117

        """

   118

        self.ItemsDict.pop(item.GetVariable(), None)

   119

   120

    def ClearItems(self):

   121

        """

   122

        Clear list of items displayed by Viewer

   123

        """

   124

        # Unsubscribe every items of the list

   125

        for item in self.Items:

   126

            self.ParentWindow.RemoveDataConsumer(item)

   127

   128

        # Clear list

   129

        self.ItemsDict.clear()

   130

   131

    def ItemsIsEmpty(self):

   132

        """

   133

        Return if list of items displayed by Viewer is empty

   134

        @return: True if list is empty

   135

        """

   136

        return len(self.Items) == 0

   137

   138

    def SubscribeAllDataConsumers(self):

   139

        """

   140

        Function that unsubscribe and remove every item that store values of

   141

        a variable that doesn't exist in PLC anymore

   142

        """

   143

        for item in self.ItemsDict.values()[:]:

   144

            iec_path = item.GetVariable()

   145

   146

            # Check that variablepath exist in PLC

   147

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

   148

                # If not, unsubscribe and remove it

   149

                self.ParentWindow.RemoveDataConsumer(item)

   150

                self.RemoveItem(item)

   151

            else:

   152

                # If it exist, resubscribe and refresh data type

   153

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

   154

                item.RefreshVariableType()

   155

   156

    def ResetItemsData(self):

   157

        """

   158

        Reset data stored in every items displayed in Viewer

   159

        """

   160

        for item in self.Items:

   161

            item.ResetData()

   162

   163

    def GetItemsMinCommonTick(self):

   164

        """

   165

        Return the minimum tick common to all iems displayed in Viewer

   166

        @return: Minimum common tick between items

   167

        """

   168

        return reduce(max, [item.GetData()[0, 0] 

   169

                            for item in self.Items

   170

                            if len(item.GetData()) > 0], 0)

   171

   172

    def RefreshViewer(self):

   173

        """

   174

        Method that refresh the content displayed by Viewer

   175

        Need to be overridden by inherited classes

   176

        """

   177

        pass

   178

   179

    def SetHighlight(self, highlight):

   180

        """

   181

        Set Highlight type displayed in Viewer

   182

        @return: True if highlight has changed

   183

        """

   184

        # Return immediately if highlight don't change

   185

        if self.Highlight == highlight:

   186

            return False

   187

   188

        self.Highlight = highlight

   189

        return True

   190

   191

    def GetButtons(self):

   192

        """

   193

        Return list of buttons defined in Viewer

   194

        @return: List of buttons

   195

        """

   196

        return self.Buttons

   197

   198

    def IsOverButton(self, x, y):

   199

        """

   200

        Return if point is over one button of Viewer

   201

        @param x: X coordinate of point

   202

        @param y: Y coordinate of point

   203

        @return: button where point is over

   204

        """

   205

        for button in self.GetButtons():

   206

            if button.HitTest(x, y):

   207

                return button

   208

        return None

   209

   210

    def HandleButton(self, x, y):

   211

        """

   212

        Search for the button under point and if found execute associated

   213

        callback

   214

        @param x: X coordinate of point

   215

        @param y: Y coordinate of point

   216

        @return: True if a button was found and callback executed

   217

        """

   218

        button = self.IsOverButton(x, y)

   219

        if button is None:

   220

            return False

   221

   222

        button.ProcessCallback()

   223

        return True

   224

   225

    def ShowButtons(self, show):

   226

        """

   227

        Set display state of buttons in Viewer

   228

        @param show: Display state (True if buttons must be displayed)

   229

        """

   230

        # Change display of every buttons

   231

        for button in self.Buttons:

   232

            button.Show(show)

   233

   234

        # Refresh button positions

   235

        self.RefreshButtonsPosition()

   236

        self.RefreshViewer()

   237

   238

    def RefreshButtonsPosition(self):

   239

        """

   240

        Function that refresh buttons position in Viewer

   241

        """

   242

        # Get Viewer size

   243

        width, height = self.GetSize()

   244

   245

        # Buttons are align right so we calculate buttons positions in

   246

        # reverse order

   247

        buttons = self.Buttons[:]

   248

        buttons.reverse()

   249

   250

        # Position offset on x coordinate

   251

        x_offset = 0

   252

        for button in buttons:

   253

            # Buttons are stacked right, removing those that are not active 

   254

            if button.IsEnabled():

   255

                # Update button position according to button width and offset

   256

                # on x coordinate

   257

                w, h = button.GetSize()

   258

                button.SetPosition(width - 5 - w - x_offset, 5)

   259

                # Update offset on x coordinate

   260

                x_offset += w + 2

   261

   262

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

   263

        """

   264

        Function that draw common graphics for every Viewers

   265

        @param dc: wx.DC object corresponding to Device context where drawing

   266

        common graphics

   267

        @param buttons: List of buttons to draw if different from default

   268

        (default None)

   269

        """

   270

        # Get Viewer size

   271

        width, height = self.GetSize()

   272

   273

        # Set dc styling for drop before or drop after highlight

   274

        dc.SetPen(HIGHLIGHT_DROP_PEN)

   275

        dc.SetBrush(HIGHLIGHT_DROP_BRUSH)

   276

   277

        # Draw line at upper side of Viewer if highlight is drop before

   278

        if self.Highlight == HIGHLIGHT_BEFORE:

   279

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

   280

   281

        # Draw line at lower side of Viewer if highlight is drop before

   282

        elif self.Highlight == HIGHLIGHT_AFTER:

   283

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

   284

   285

        # If no specific buttons are defined, get default buttons

   286

        if buttons is None:

   287

            buttons = self.Buttons

   288

        # Draw buttons

   289

        for button in buttons:

   290

            button.Draw(dc)

   291

   292

        # If graph dragging is processing

   293

        if self.ParentWindow.IsDragging():

   294

            destBBox = self.ParentWindow.GetDraggingAxesClippingRegion(self)

   295

            srcPos = self.ParentWindow.GetDraggingAxesPosition(self)

   296

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

   297

                srcPanel = self.ParentWindow.DraggingAxesPanel

   298

                srcBBox = srcPanel.GetAxesBoundingBox()

   299

   300

                srcX = srcBBox.x - (srcPos.x if destBBox.x == 0 else 0)

   301

                srcY = srcBBox.y - (srcPos.y if destBBox.y == 0 else 0)

   302

   303

                srcBmp = _convert_agg_to_wx_bitmap(

   304

                            srcPanel.get_renderer(), None)

   305

                srcDC = wx.MemoryDC()

   306

                srcDC.SelectObject(srcBmp)

   307

   308

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

   309

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

   310

                        srcDC, srcX, srcY)

   311

   312

    def OnEnter(self, event):

   313

        """

   314

        Function called when entering Viewer

   315

        @param event: wx.MouseEvent 

   316

        """

   317

        # Display buttons

   318

        self.ShowButtons(True)

   319

        event.Skip()

   320

   321

    def OnLeave(self, event):

   322

        """

   323

        Function called when leaving Viewer

   324

        @param event: wx.MouseEvent 

   325

        """

   326

        # Hide buttons

   327

        self.ShowButtons(False)

   328

        event.Skip()

   329

   330

    def OnCloseButton(self):

   331

        """

   332

        Function called when Close button is pressed

   333

        """

   334

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

   335

   336

    def OnForceButton(self):

   337

        """

   338

        Function called when Force button is pressed

   339

        """

   340

        self.ForceValue(self.ItemsDict.values()[0])

   341

   342

    def OnReleaseButton(self):

   343

        """

   344

        Function called when Release button is pressed

   345

        """

   346

        self.ReleaseValue(self.ItemsDict.values()[0])

   347

   348

    def OnMouseDragging(self, x, y):

   349

        """

   350

        Function called when mouse is dragged over Viewer

   351

        @param x: X coordinate of mouse pointer

   352

        @param y: Y coordinate of mouse pointer

   353

        """

   354

        xw, yw = self.GetPosition()

   355

        # Refresh highlight in Debug Variable Panel (highlight can be displayed

   356

        # in another Viewer

   357

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

   358

   359

    def RefreshHighlight(self, x, y):

   360

        """

   361

        Function called by Debug Variable Panel asking Viewer to refresh

   362

        highlight according to mouse position

   363

        @param x: X coordinate of mouse pointer

   364

        @param y: Y coordinate of mouse pointer

   365

        """

   366

        # Get Viewer size

   367

        width, height = self.GetSize()

   368

   369

        # Mouse is in the first half of Viewer

   370

        if y < height / 2:

   371

            # If Viewer is the upper one, draw drop before highlight

   372

            if self.ParentWindow.IsViewerFirst(self):

   373

                self.SetHighlight(HIGHLIGHT_BEFORE)

   374

   375

            # Else draw drop after highlight in previous Viewer

   376

            else:

   377

                self.SetHighlight(HIGHLIGHT_NONE)

   378

                self.ParentWindow.HighlightPreviousViewer(self)

   379

   380

        # Mouse is in the second half of Viewer, draw drop after highlight 

   381

        else:

   382

            self.SetHighlight(HIGHLIGHT_AFTER)

   383

   384

    def OnEraseBackground(self, event):

   385

        """

   386

        Function called when Viewer background is going to be erase

   387

        @param event: wx.EraseEvent

   388

        """

   389

        # Prevent flicker on Windows

   390

        pass

   391

   392

    def OnResize(self, event):

   393

        """

   394

        Function called when Viewer size changed

   395

        @param event: wx.ResizeEvent

   396

        """

   397

        # Refresh button positions

   398

        self.RefreshButtonsPosition()

   399

        self.ParentWindow.ForceRefresh()

   400

        event.Skip()

   401

   402

    def ForceValue(self, item):

   403

        """

   404

        Force value of item given

   405

        @param item: Item to force value

   406

        """

   407

        # Check variable data type

   408

        iec_path = item.GetVariable()

   409

        iec_type = self.ParentWindow.GetDataType(iec_path)

   410

        # Return immediately if not found

   411

        if iec_type is None:

   412

            return

   413

   414

        # Open a dialog to enter varaible forced value

   415

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

   416

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

   417

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

   418

                                             dialog.GetValue())

   419

   420

    def ReleaseValue(self, item):

   421

        """

   422

        Release value of item given

   423

        @param item: Item to release value

   424

        """

   425

        self.ParentWindow.ReleaseDataValue(

   426

                item.GetVariable().upper())