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

from collections import OrderedDict

    26

    27

import wx

    28

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    29

    30

from dialogs.ForceVariableDialog import ForceVariableDialog

    31

    32

# Viewer highlight types

    33

[HIGHLIGHT_NONE,

    34

 HIGHLIGHT_BEFORE,

    35

 HIGHLIGHT_AFTER,

    36

 HIGHLIGHT_LEFT,

    37

 HIGHLIGHT_RIGHT,

    38

 HIGHLIGHT_RESIZE] = range(6)

    39

    40

# Viewer highlight styles

    41

HIGHLIGHT = {

    42

}

    43

    44

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

    45

#                        Base Debug Variable Viewer Class

    46

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

    47

    48

    49

class DebugVariableViewer(object):

    50

    """

    51

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

    52

    This class has to be inherited to effectively display variable values

    53

    """

    54

    55

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

    56

        """

    57

        Constructor

    58

        @param window: Reference to the Debug Variable Panel

    59

        @param items: List of DebugVariableItem displayed by Viewer

    60

        """

    61

        self.ParentWindow = window

    62

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

    63

                                      for item in items])

    64

        self.Items = self.ItemsDict.viewvalues()

    65

    66

        # Variable storing current highlight displayed in Viewer

    67

        self.Highlight = HIGHLIGHT_NONE

    68

        # List of buttons

    69

        self.Buttons = []

    70

        self.InitHighlightPensBrushes()

    71

    72

    def __del__(self):

    73

        """

    74

        Destructor

    75

        """

    76

        # Remove reference to Debug Variable Panel

    77

        self.ParentWindow = None

    78

    79

    def InitHighlightPensBrushes(self):

    80

        """

    81

        Init global pens and brushes

    82

        """

    83

        if not HIGHLIGHT:

    84

            HIGHLIGHT['DROP_PEN'] = wx.Pen(wx.Colour(0, 128, 255))

    85

            HIGHLIGHT['DROP_BRUSH'] = wx.Brush(wx.Colour(0, 128, 255, 128))

    86

            HIGHLIGHT['RESIZE_PEN'] = wx.Pen(wx.Colour(200, 200, 200))

    87

            HIGHLIGHT['RESIZE_BRUSH'] = wx.Brush(wx.Colour(200, 200, 200))

    88

    89

    def GetIndex(self):

    90

        """

    91

        Return position of Viewer in Debug Variable Panel

    92

        @return: Position of Viewer

    93

        """

    94

        return self.ParentWindow.GetViewerIndex(self)

    95

    96

    def GetItem(self, variable):

    97

        """

    98

        Return item storing values of a variable

    99

        @param variable: Variable path

   100

        @return: Item storing values of this variable

   101

        """

   102

        return self.ItemsDict.get(variable, None)

   103

   104

    def GetItems(self):

   105

        """

   106

        Return items displayed by Viewer

   107

        @return: List of items displayed in Viewer

   108

        """

   109

        return self.ItemsDict.values()

   110

   111

    def AddItem(self, item):

   112

        """

   113

        Add an item to the list of items displayed by Viewer

   114

        @param item: Item to add to the list

   115

        """

   116

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

   117

   118

    def RemoveItem(self, item):

   119

        """

   120

        Remove an item from the list of items displayed by Viewer

   121

        @param item: Item to remove from the list

   122

        """

   123

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

   124

   125

    def ClearItems(self):

   126

        """

   127

        Clear list of items displayed by Viewer

   128

        """

   129

        # Unsubscribe every items of the list

   130

        for item in self.Items:

   131

            self.ParentWindow.RemoveDataConsumer(item)

   132

   133

        # Clear list

   134

        self.ItemsDict.clear()

   135

   136

    def ItemsIsEmpty(self):

   137

        """

   138

        Return if list of items displayed by Viewer is empty

   139

        @return: True if list is empty

   140

        """

   141

        return len(self.Items) == 0

   142

   143

    def SubscribeAllDataConsumers(self):

   144

        """

   145

        Function that unsubscribe and remove every item that store values of

   146

        a variable that doesn't exist in PLC anymore

   147

        """

   148

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

   149

            iec_path = item.GetVariable()

   150

   151

            # Check that variablepath exist in PLC

   152

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

   153

                # If not, unsubscribe and remove it

   154

                self.ParentWindow.RemoveDataConsumer(item)

   155

                self.RemoveItem(item)

   156

            else:

   157

                # If it exist, resubscribe and refresh data type

   158

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

   159

                item.RefreshVariableType()

   160

   161

    def ResetItemsData(self):

   162

        """

   163

        Reset data stored in every items displayed in Viewer

   164

        """

   165

        for item in self.Items:

   166

            item.ResetData()

   167

   168

    def GetItemsMinCommonTick(self):

   169

        """

   170

        Return the minimum tick common to all iems displayed in Viewer

   171

        @return: Minimum common tick between items

   172

        """

   173

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

   174

                            for item in self.Items

   175

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

   176

   177

    def RefreshViewer(self):

   178

        """

   179

        Method that refresh the content displayed by Viewer

   180

        Need to be overridden by inherited classes

   181

        """

   182

        pass

   183

   184

    def SetHighlight(self, highlight):

   185

        """

   186

        Set Highlight type displayed in Viewer

   187

        @return: True if highlight has changed

   188

        """

   189

        # Return immediately if highlight don't change

   190

        if self.Highlight == highlight:

   191

            return False

   192

   193

        self.Highlight = highlight

   194

        return True

   195

   196

    def GetButtons(self):

   197

        """

   198

        Return list of buttons defined in Viewer

   199

        @return: List of buttons

   200

        """

   201

        return self.Buttons

   202

   203

    def IsOverButton(self, x, y):

   204

        """

   205

        Return if point is over one button of Viewer

   206

        @param x: X coordinate of point

   207

        @param y: Y coordinate of point

   208

        @return: button where point is over

   209

        """

   210

        for button in self.GetButtons():

   211

            if button.HitTest(x, y):

   212

                return button

   213

        return None

   214

   215

    def HandleButton(self, x, y):

   216

        """

   217

        Search for the button under point and if found execute associated

   218

        callback

   219

        @param x: X coordinate of point

   220

        @param y: Y coordinate of point

   221

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

   222

        """

   223

        button = self.IsOverButton(x, y)

   224

        if button is None:

   225

            return False

   226

   227

        button.ProcessCallback()

   228

        return True

   229

   230

    def ShowButtons(self, show):

   231

        """

   232

        Set display state of buttons in Viewer

   233

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

   234

        """

   235

        # Change display of every buttons

   236

        for button in self.Buttons:

   237

            button.Show(show)

   238

   239

        # Refresh button positions

   240

        self.RefreshButtonsPosition()

   241

        self.RefreshViewer()

   242

   243

    def RefreshButtonsPosition(self):

   244

        """

   245

        Function that refresh buttons position in Viewer

   246

        """

   247

        # Get Viewer size

   248

        width, _height = self.GetSize()

   249

   250

        # Buttons are align right so we calculate buttons positions in

   251

        # reverse order

   252

        buttons = self.Buttons[:]

   253

        buttons.reverse()

   254

   255

        # Position offset on x coordinate

   256

        x_offset = 0

   257

        for button in buttons:

   258

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

   259

            if button.IsEnabled():

   260

                # Update button position according to button width and offset

   261

                # on x coordinate

   262

                w, _h = button.GetSize()

   263

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

   264

                # Update offset on x coordinate

   265

                x_offset += w + 2

   266

   267

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

   268

        """

   269

        Function that draw common graphics for every Viewers

   270

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

   271

        common graphics

   272

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

   273

        (default None)

   274

        """

   275

        # Get Viewer size

   276

        width, height = self.GetSize()

   277

   278

        # Set dc styling for drop before or drop after highlight

   279

        dc.SetPen(HIGHLIGHT['DROP_PEN'])

   280

        dc.SetBrush(HIGHLIGHT['DROP_BRUSH'])

   281

   282

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

   283

        if self.Highlight == HIGHLIGHT_BEFORE:

   284

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

   285

   286

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

   287

        elif self.Highlight == HIGHLIGHT_AFTER:

   288

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

   289

   290

        # If no specific buttons are defined, get default buttons

   291

        if buttons is None:

   292

            buttons = self.Buttons

   293

        # Draw buttons

   294

        for button in buttons:

   295

            button.Draw(dc)

   296

   297

        # If graph dragging is processing

   298

        if self.ParentWindow.IsDragging():

   299

            destBBox = self.ParentWindow.GetDraggingAxesClippingRegion(self)

   300

            srcPos = self.ParentWindow.GetDraggingAxesPosition(self)

   301

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

   302

                srcPanel = self.ParentWindow.DraggingAxesPanel

   303

                srcBBox = srcPanel.GetAxesBoundingBox()

   304

   305

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

   306

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

   307

   308

                srcBmp = _convert_agg_to_wx_bitmap(

   309

                            srcPanel.get_renderer(), None)

   310

                srcDC = wx.MemoryDC()

   311

                srcDC.SelectObject(srcBmp)

   312

   313

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

   314

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

   315

                        srcDC, srcX, srcY)

   316

   317

    def OnEnter(self, event):

   318

        """

   319

        Function called when entering Viewer

   320

        @param event: wx.MouseEvent

   321

        """

   322

        # Display buttons

   323

        self.ShowButtons(True)

   324

        event.Skip()

   325

   326

    def OnLeave(self, event):

   327

        """

   328

        Function called when leaving Viewer

   329

        @param event: wx.MouseEvent

   330

        """

   331

        # Hide buttons

   332

        self.ShowButtons(False)

   333

        event.Skip()

   334

   335

    def OnCloseButton(self):

   336

        """

   337

        Function called when Close button is pressed

   338

        """

   339

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

   340

   341

    def OnForceButton(self):

   342

        """

   343

        Function called when Force button is pressed

   344

        """

   345

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

   346

   347

    def OnReleaseButton(self):

   348

        """

   349

        Function called when Release button is pressed

   350

        """

   351

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

   352

   353

    def OnMouseDragging(self, x, y):

   354

        """

   355

        Function called when mouse is dragged over Viewer

   356

        @param x: X coordinate of mouse pointer

   357

        @param y: Y coordinate of mouse pointer

   358

        """

   359

        xw, yw = self.GetPosition()

   360

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

   361

        # in another Viewer

   362

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

   363

   364

    def RefreshHighlight(self, x, y):

   365

        """

   366

        Function called by Debug Variable Panel asking Viewer to refresh

   367

        highlight according to mouse position

   368

        @param x: X coordinate of mouse pointer

   369

        @param y: Y coordinate of mouse pointer

   370

        """

   371

        # Get Viewer size

   372

        _width, height = self.GetSize()

   373

   374

        # Mouse is in the first half of Viewer

   375

        if y < height / 2:

   376

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

   377

            if self.ParentWindow.IsViewerFirst(self):

   378

                self.SetHighlight(HIGHLIGHT_BEFORE)

   379

   380

            # Else draw drop after highlight in previous Viewer

   381

            else:

   382

                self.SetHighlight(HIGHLIGHT_NONE)

   383

                self.ParentWindow.HighlightPreviousViewer(self)

   384

   385

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

   386

        else:

   387

            self.SetHighlight(HIGHLIGHT_AFTER)

   388

   389

    def OnEraseBackground(self, event):

   390

        """

   391

        Function called when Viewer background is going to be erase

   392

        @param event: wx.EraseEvent

   393

        """

   394

        # Prevent flicker on Windows

   395

        pass

   396

   397

    def OnResize(self, event):

   398

        """

   399

        Function called when Viewer size changed

   400

        @param event: wx.ResizeEvent

   401

        """

   402

        # Refresh button positions

   403

        self.RefreshButtonsPosition()

   404

        self.ParentWindow.ForceRefresh()

   405

        event.Skip()

   406

   407

    def ForceValue(self, item):

   408

        """

   409

        Force value of item given

   410

        @param item: Item to force value

   411

        """

   412

        # Check variable data type

   413

        iec_path = item.GetVariable()

   414

        iec_type = self.ParentWindow.GetDataType(iec_path)

   415

        # Return immediately if not found

   416

        if iec_type is None:

   417

            return

   418

   419

        # Open a dialog to enter varaible forced value

   420

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

   421

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

   422

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

   423

                                             dialog.GetValue())

   424

   425

    def ReleaseValue(self, item):

   426

        """

   427

        Release value of item given

   428

        @param item: Item to release value

   429

        """

   430

        self.ParentWindow.ReleaseDataValue(

   431

                item.GetVariable().upper())