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

    26

    27

    28

from collections import OrderedDict

    29

from functools import reduce

    30

    31

import wx

    32

    33

from dialogs.ForceVariableDialog import ForceVariableDialog

    34

    35

# Viewer highlight types

    36

[HIGHLIGHT_NONE,

    37

 HIGHLIGHT_BEFORE,

    38

 HIGHLIGHT_AFTER,

    39

 HIGHLIGHT_LEFT,

    40

 HIGHLIGHT_RIGHT,

    41

 HIGHLIGHT_RESIZE] = list(range(6))

    42

    43

# Viewer highlight styles

    44

HIGHLIGHT = {

    45

}

    46

    47

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

    48

#                        Base Debug Variable Viewer Class

    49

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

    50

    51

    52

class DebugVariableViewer(object):

    53

    """

    54

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

    55

    This class has to be inherited to effectively display variable values

    56

    """

    57

    58

    def __init__(self, window, items=None):

    59

        """

    60

        Constructor

    61

        @param window: Reference to the Debug Variable Panel

    62

        @param items: List of DebugVariableItem displayed by Viewer

    63

        """

    64

        self.ParentWindow = window

    65

        items = [] if items is None else items

    66

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

    67

                                      for item in items])

    68

        self.Items = self.ItemsDict.values()

    69

    70

        # Variable storing current highlight displayed in Viewer

    71

        self.Highlight = HIGHLIGHT_NONE

    72

        # List of buttons

    73

        self.Buttons = []

    74

        self.InitHighlightPensBrushes()

    75

    76

    def InitHighlightPensBrushes(self):

    77

        """

    78

        Init global pens and brushes

    79

        """

    80

        if not HIGHLIGHT:

    81

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

    82

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

    83

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

    84

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

    85

    86

    def GetIndex(self):

    87

        """

    88

        Return position of Viewer in Debug Variable Panel

    89

        @return: Position of Viewer

    90

        """

    91

        return self.ParentWindow.GetViewerIndex(self)

    92

    93

    def GetItem(self, variable):

    94

        """

    95

        Return item storing values of a variable

    96

        @param variable: Variable path

    97

        @return: Item storing values of this variable

    98

        """

    99

        return self.ItemsDict.get(variable, None)

   100

   101

    def GetItems(self):

   102

        """

   103

        Return items displayed by Viewer

   104

        @return: List of items displayed in Viewer

   105

        """

   106

        return list(self.ItemsDict.values())

   107

   108

    def AddItem(self, item):

   109

        """

   110

        Add an item to the list of items displayed by Viewer

   111

        @param item: Item to add to the list

   112

        """

   113

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

   114

   115

    def RemoveItem(self, item):

   116

        """

   117

        Remove an item from the list of items displayed by Viewer

   118

        @param item: Item to remove from the list

   119

        """

   120

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

   121

   122

    def ClearItems(self):

   123

        """

   124

        Clear list of items displayed by Viewer

   125

        """

   126

        # Unsubscribe every items of the list

   127

        for item in self.Items:

   128

            self.ParentWindow.RemoveDataConsumer(item)

   129

   130

        # Clear list

   131

        self.ItemsDict.clear()

   132

   133

    def ItemsIsEmpty(self):

   134

        """

   135

        Return if list of items displayed by Viewer is empty

   136

        @return: True if list is empty

   137

        """

   138

        return len(self.Items) == 0

   139

   140

    def SubscribeAllDataConsumers(self):

   141

        """

   142

        Function that unsubscribe and remove every item that store values of

   143

        a variable that doesn't exist in PLC anymore

   144

        """

   145

        for item in self.ItemsDict.values():

   146

            iec_path = item.GetVariable()

   147

   148

            # Check that variablepath exist in PLC

   149

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

   150

                # If not, unsubscribe and remove it

   151

                self.ParentWindow.RemoveDataConsumer(item)

   152

                self.RemoveItem(item)

   153

            else:

   154

                # If it exist, resubscribe and refresh data type

   155

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

   156

                item.RefreshVariableType()

   157

   158

    def ResetItemsData(self):

   159

        """

   160

        Reset data stored in every items displayed in Viewer

   161

        """

   162

        for item in self.Items:

   163

            item.ResetData()

   164

   165

    def GetItemsMinCommonTick(self):

   166

        """

   167

        Return the minimum tick common to all iems displayed in Viewer

   168

        @return: Minimum common tick between items

   169

        """

   170

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

   171

                            for item in self.Items

   172

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

   173

   174

    def RefreshViewer(self):

   175

        """

   176

        Method that refresh the content displayed by Viewer

   177

        Need to be overridden by inherited classes

   178

        """

   179

        pass

   180

   181

    def SetHighlight(self, highlight):

   182

        """

   183

        Set Highlight type displayed in Viewer

   184

        @return: True if highlight has changed

   185

        """

   186

        # Return immediately if highlight don't change

   187

        if self.Highlight == highlight:

   188

            return False

   189

   190

        self.Highlight = highlight

   191

        return True

   192

   193

    def GetButtons(self):

   194

        """

   195

        Return list of buttons defined in Viewer

   196

        @return: List of buttons

   197

        """

   198

        return self.Buttons

   199

   200

    def IsOverButton(self, x, y):

   201

        """

   202

        Return if point is over one button of Viewer

   203

        @param x: X coordinate of point

   204

        @param y: Y coordinate of point

   205

        @return: button where point is over

   206

        """

   207

        for button in self.GetButtons():

   208

            if button.HitTest(x, y):

   209

                return button

   210

        return None

   211

   212

    def HandleButton(self, x, y):

   213

        """

   214

        Search for the button under point and if found execute associated

   215

        callback

   216

        @param x: X coordinate of point

   217

        @param y: Y coordinate of point

   218

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

   219

        """

   220

        button = self.IsOverButton(x, y)

   221

        if button is None:

   222

            return False

   223

   224

        button.ProcessCallback()

   225

        return True

   226

   227

    def ShowButtons(self, show):

   228

        """

   229

        Set display state of buttons in Viewer

   230

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

   231

        """

   232

        # Change display of every buttons

   233

        for button in self.Buttons:

   234

            button.Show(show)

   235

   236

        # Refresh button positions

   237

        self.RefreshButtonsPosition()

   238

        self.RefreshViewer()

   239

   240

    def RefreshButtonsPosition(self):

   241

        """

   242

        Function that refresh buttons position in Viewer

   243

        """

   244

        # Get Viewer size

   245

        width, _height = self.GetSize()

   246

   247

        # Buttons are align right so we calculate buttons positions in

   248

        # reverse order

   249

        buttons = self.Buttons[:]

   250

        buttons.reverse()

   251

   252

        # Position offset on x coordinate

   253

        x_offset = 0

   254

        for button in buttons:

   255

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

   256

            if button.IsEnabled():

   257

                # Update button position according to button width and offset

   258

                # on x coordinate

   259

                w, _h = button.GetSize()

   260

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

   261

                # Update offset on x coordinate

   262

                x_offset += w + 2

   263

   264

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

   265

        """

   266

        Function that draw common graphics for every Viewers

   267

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

   268

        common graphics

   269

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

   270

        (default None)

   271

        """

   272

        # Get Viewer size

   273

        width, height = self.GetSize()

   274

   275

        # Set dc styling for drop before or drop after highlight

   276

        dc.SetPen(HIGHLIGHT['DROP_PEN'])

   277

        dc.SetBrush(HIGHLIGHT['DROP_BRUSH'])

   278

   279

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

   280

        if self.Highlight == HIGHLIGHT_BEFORE:

   281

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

   282

   283

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

   284

        elif self.Highlight == HIGHLIGHT_AFTER:

   285

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

   286

   287

        # If no specific buttons are defined, get default buttons

   288

        if buttons is None:

   289

            buttons = self.Buttons

   290

        # Draw buttons

   291

        for button in buttons:

   292

            button.Draw(dc)

   293

   294

        # If graph dragging is processing

   295

        if self.ParentWindow.IsDragging():

   296

            destBBox = self.ParentWindow.GetDraggingAxesClippingRegion(self)

   297

            srcPos = self.ParentWindow.GetDraggingAxesPosition(self)

   298

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

   299

                srcPanel = self.ParentWindow.DraggingAxesPanel

   300

                srcBBox = srcPanel.GetAxesBoundingBox()

   301

   302

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

   303

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

   304

   305

                agg_bitmap = srcPanel.get_renderer()

   306

                srcBmp = wx.Bitmap.FromBufferRGBA(int(agg_bitmap.width), int(agg_bitmap.height),

   307

                                        agg_bitmap.buffer_rgba())

   308

   309

                srcDC = wx.MemoryDC()

   310

                srcDC.SelectObject(srcBmp)

   311

   312

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

   313

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

   314

                        srcDC, srcX, srcY)

   315

   316

    def OnEnter(self, event):

   317

        """

   318

        Function called when entering Viewer

   319

        @param event: wx.MouseEvent

   320

        """

   321

        # Display buttons

   322

        self.ShowButtons(True)

   323

        event.Skip()

   324

   325

    def OnLeave(self, event):

   326

        """

   327

        Function called when leaving Viewer

   328

        @param event: wx.MouseEvent

   329

        """

   330

        # Hide buttons

   331

        self.ShowButtons(False)

   332

        event.Skip()

   333

   334

    def OnCloseButton(self):

   335

        """

   336

        Function called when Close button is pressed

   337

        """

   338

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

   339

   340

    def OnForceButton(self):

   341

        """

   342

        Function called when Force button is pressed

   343

        """

   344

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

   345

   346

    def OnReleaseButton(self):

   347

        """

   348

        Function called when Release button is pressed

   349

        """

   350

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

   351

   352

    def OnMouseDragging(self, x, y):

   353

        """

   354

        Function called when mouse is dragged over Viewer

   355

        @param x: X coordinate of mouse pointer

   356

        @param y: Y coordinate of mouse pointer

   357

        """

   358

        xw, yw = self.GetPosition()

   359

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

   360

        # in another Viewer

   361

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

   362

   363

    def RefreshHighlight(self, x, y):

   364

        """

   365

        Function called by Debug Variable Panel asking Viewer to refresh

   366

        highlight according to mouse position

   367

        @param x: X coordinate of mouse pointer

   368

        @param y: Y coordinate of mouse pointer

   369

        """

   370

        # Get Viewer size

   371

        _width, height = self.GetSize()

   372

   373

        # Mouse is in the first half of Viewer

   374

        if y < height // 2:

   375

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

   376

            if self.ParentWindow.IsViewerFirst(self):

   377

                self.SetHighlight(HIGHLIGHT_BEFORE)

   378

   379

            # Else draw drop after highlight in previous Viewer

   380

            else:

   381

                self.SetHighlight(HIGHLIGHT_NONE)

   382

                self.ParentWindow.HighlightPreviousViewer(self)

   383

   384

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

   385

        else:

   386

            self.SetHighlight(HIGHLIGHT_AFTER)

   387

   388

    def OnEraseBackground(self, event):

   389

        """

   390

        Function called when Viewer background is going to be erase

   391

        @param event: wx.EraseEvent

   392

        """

   393

        # Prevent flicker on Windows

   394

        pass

   395

   396

    def OnResize(self, event):

   397

        """

   398

        Function called when Viewer size changed

   399

        @param event: wx.ResizeEvent

   400

        """

   401

        # Refresh button positions

   402

        self.RefreshButtonsPosition()

   403

        self.ParentWindow.ForceRefresh()

   404

        event.Skip()

   405

   406

    def ForceValue(self, item):

   407

        """

   408

        Force value of item given

   409

        @param item: Item to force value

   410

        """

   411

        # Check variable data type

   412

        iec_path = item.GetVariable()

   413

        iec_type = self.ParentWindow.GetDataType(iec_path)

   414

        # Return immediately if not found

   415

        if iec_type is None:

   416

            return

   417

   418

        # Open a dialog to enter varaible forced value

   419

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

   420

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

   421

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

   422

                                             dialog.GetValue())

   423

   424

    def ReleaseValue(self, item):

   425

        """

   426

        Release value of item given

   427

        @param item: Item to release value

   428

        """

   429

        self.ParentWindow.ReleaseDataValue(

   430

            item.GetVariable().upper())