45

# Graph variable display type

    48

# Canvas height

    51

CANVAS_BORDER = (20., 10.) # Border height on at bottom and top of graph

    52

CANVAS_PADDING = 8.5       # Border inside graph where no label is drawn

    53

VALUE_LABEL_HEIGHT = 17.   # Height of variable label in graph

    54

AXES_LABEL_HEIGHT = 12.75  # Height of variable value in graph

    55

    56

# Colors used cyclically for graph curves

    58

# Color for graph cursor

    61

def OrthogonalDataAndRange(item, start_tick, end_tick):

    72

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

    73

#                   Debug Variable Graphic Viewer Drop Target

    74

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

    75

    76

"""

    77

Class that implements a custom drop target class for Debug Variable Graphic Viewer

    78

"""

    79

    80

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

    83

        """

    84

        Constructor

    85

        @param parent: Reference to Debug Variable Graphic Viewer

    86

        @param window: Reference to the Debug Variable Panel

    87

        """

    93

        """

    94

        Destructor

    95

        """

    96

        # Remove reference to Debug Variable Graphic Viewer and Debug Variable

    97

        # Panel

   102

        """

   103

        Function called when mouse is dragged over Drop Target

   104

        @param x: X coordinate of mouse pointer

   105

        @param y: Y coordinate of mouse pointer

   106

        @param d: Suggested default for return value

   107

        """

   108

        # Signal parent that mouse is dragged over

   110

   114

        """

   115

        Function called when mouse is dragged over Drop Target

   116

        @param x: X coordinate of mouse pointer

   117

        @param y: Y coordinate of mouse pointer

   118

        @param data: Text associated to drag'n drop

   119

        """

   121

   122

        # Check that data is valid regarding DebugVariablePanel

   131

        # Display message if data is invalid

   135

        # Data contain a reference to a variable to debug

   138

   139

            # If mouse is dropped in graph canvas bounding box and graph is

   140

            # not 3D canvas, graphs will be merged

   141

            rect = self.ParentControl.GetAxesBoundingBox()

   142

            if not self.ParentControl.Is3DCanvas() and rect.InsideXY(x, y):

   143

                # Default merge type is parallel

   144

                merge_type = GRAPH_PARALLEL

   145

   146

                # If mouse is dropped in left part of graph canvas, graph

   147

                # wall be merged orthogonally

   148

                merge_rect = wx.Rect(rect.x, rect.y, 

   149

                                     rect.width / 2., rect.height)

   150

                if merge_rect.InsideXY(x, y):

   151

                    merge_type = GRAPH_ORTHOGONAL

   152

   153

                # Merge graphs

   154

                wx.CallAfter(self.ParentWindow.MergeGraphs, 

   155

                             values[0], target_idx, 

   156

                             merge_type, force=True)

   157

   158

            else:

   159

                width, height = self.ParentControl.GetSize()

   160

   161

                # Get Before which Viewer the variable has to be moved or added

   162

                # according to the position of mouse in Viewer.

   165

   166

                # Drag'n Drop is an internal is an internal move inside Debug

   167

                # Variable Panel 

   168

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

   169

                    self.ParentWindow.MoveValue(values[0], 

   170

                                                target_idx)

   171

   172

                # Drag'n Drop was initiated by another control of Beremiz

   174

                    self.ParentWindow.InsertValue(values[0], 

   175

                                                  target_idx, 

   176

                                                  force=True)

   179

        """

   180

        Function called when mouse is leave Drop Target

   181

        """

   182

        # Signal Debug Variable Panel to reset highlight

   187

        """

   188

        Show error message in Error Dialog

   189

        @param message: Error message to display

   190

        """

   196

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

   197

#                      Debug Variable Graphic Viewer Class

   198

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

   199

   200

"""

   201

Class that implements a Viewer that display variable values as a graphs

   202

"""

   203

   207

        """

   208

        Constructor

   209

        @param parent: Parent wx.Window of DebugVariableText

   210

        @param window: Reference to the Debug Variable Panel

   211

        @param items: List of DebugVariableItem displayed by Viewer

   212

        @param graph_type: Graph display type (Parallel or orthogonal)

   213

        """

   216

        self.GraphType = graph_type        # Graph type display

   217

        self.CursorTick = None             # Tick of the graph cursor

   218

   219

        # Mouse position when start dragging

   221

        # Tick when moving tick start

   223

        # Canvas size when starting to resize canvas

   224

        self.CanvasStartSize = None        

   225

   226

        # List of current displayed contextual buttons

   228

        # Reference to item for which contextual buttons was displayed

   231

        # Create figure for drawing graphs

   233

        # Defined border around figure in canvas

   234

        self.Figure.subplotpars.update(top=0.95, left=0.1, 

   235

                                       bottom=0.1, right=0.95)

   240

   241

        # Bind wx events

   248

        # Set canvas min size

   251

   252

        # Define Viewer drop target

   253

        self.SetDropTarget(DebugVariableGraphicDropTarget(self, window))

   254

   255

        # Connect matplotlib events

   261

        # Add buttons for changing canvas size with predefined height

   262

        for size, bitmap in zip(

   263

                [SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI],

   264

                ["minimize_graph", "middle_graph", "maximize_graph"]):

   265

            self.Buttons.append(

   266

                    GraphButton(0, 0, bitmap, 

   267

                                self.GetOnChangeSizeButton(size)))

   268

   269

        # Add buttons for exporting graph values to clipboard and close graph

   270

        for bitmap, callback in [

   271

                ("export_graph_mini", self.OnExportGraphButton),

   272

                ("delete_graph", self.OnCloseButton)]:

   275

        # Update graphs elements

   278

   279

    def AddItem(self, item):

   280

        """

   281

        Add an item to the list of items displayed by Viewer

   282

        @param item: Item to add to the list

   283

        """

   284

        DebugVariableViewer.AddItem(self, item)

   285

        self.ResetGraphics()

   286

   287

    def RemoveItem(self, item):

   288

        """

   289

        Remove an item from the list of items displayed by Viewer

   290

        @param item: Item to remove from the list

   291

        """

   292

        DebugVariableViewer.RemoveItem(self, item)

   293

   294

        # If list of items is not empty

   295

        if not self.ItemsIsEmpty():

   296

            # Return to parallel graph if there is only one item

   297

            # especially if it's actually orthogonal

   298

            if len(self.Items) == 1:

   299

                self.GraphType = GRAPH_PARALLEL

   300

            self.ResetGraphics()

   301

   302

    def SubscribeAllDataConsumers(self):

   303

        """

   304

        Function that unsubscribe and remove every item that store values of

   305

        a variable that doesn't exist in PLC anymore

   306

        """

   307

        DebugVariableViewer.SubscribeAllDataConsumers(self)

   308

        if not self.ItemsIsEmpty():

   309

            self.ResetGraphics()

   310

   311

    def Is3DCanvas(self):

   312

        """

   313

        Return if Viewer is a 3D canvas

   314

        @return: True if Viewer is a 3D canvas

   315

        """

   316

        return self.GraphType == GRAPH_ORTHOGONAL and len(self.Items) == 3

   319

        """

   320

        Return list of buttons defined in Viewer

   321

        @return: List of buttons

   322

        """

   323

        # Add contextual buttons to default buttons

   326

    def PopupContextualButtons(self, item, rect, direction=wx.RIGHT):

   327

        """

   328

        Show contextual menu for item aside a label of this item defined

   329

        by the bounding box of label in figure

   330

        @param item: Item for which contextual is shown

   331

        @param rect: Bounding box of label aside which drawing menu

   332

        @param direction: Direction in which buttons must be drawn

   333

        """

   334

        # Return immediately if contextual menu for item is already shown

   335

        if self.ContextualButtonsItem == item:

   336

            return

   337

   338

        # Close already shown contextual menu

   339

        self.DismissContextualButtons()

   340

   341

        # Save item for which contextual menu is shown

   342

        self.ContextualButtonsItem = item

   343

   344

        # If item variable is forced, add button for release variable to

   345

        # contextual menu

   346

        if self.ContextualButtonsItem.IsForced():

   347

            self.ContextualButtons.append(

   348

                GraphButton(0, 0, "release", self.OnReleaseItemButton))

   349

   350

        # Add other buttons to contextual menu

   351

        for bitmap, callback in [

   352

                ("force", self.OnForceItemButton),

   353

                ("export_graph_mini", self.OnExportItemGraphButton),

   354

                ("delete_graph", self.OnRemoveItemButton)]:

   355

            self.ContextualButtons.append(

   356

                    GraphButton(0, 0, bitmap, callback))

   357

   358

        # If buttons are shown at left side or upper side of rect, positions

   359

        # will be set in reverse order

   360

        buttons = self.ContextualButtons[:]

   361

        if direction in [wx.TOP, wx.LEFT]:

   362

             buttons.reverse()

   363

   364

        # Set contextual menu buttons position aside rect depending on

   365

        # direction given

   366

        offset = 0

   367

        for button in buttons:

   368

            w, h = button.GetSize()

   369

            if direction in [wx.LEFT, wx.RIGHT]:

   370

                x = rect.x + (- w - offset

   371

                            if direction == wx.LEFT

   372

                            else rect.width + offset)

   373

                y = rect.y + (rect.height - h) / 2

   374

                offset += w

   375

            else:

   376

                x = rect.x + (rect.width - w ) / 2

   377

                y = rect.y + (- h - offset

   378

                              if direction == wx.TOP

   379

                              else rect.height + offset)

   380

                offset += h

   381

            button.SetPosition(x, y)

   382

            button.Show()

   383

   384

        # Refresh canvas

   385

        self.ParentWindow.ForceRefresh()

   386

   387

    def DismissContextualButtons(self):

   388

        """

   389

        Close current shown contextual menu

   390

        """

   391

        # Return immediately if no contextual menu is shown

   393

            return

   394

   395

        # Reset variables corresponding to contextual menu

   396

        self.ContextualButtonsItem = None

   397

        self.ContextualButtons = []

   398

   399

        # Refresh canvas

   400

        self.ParentWindow.ForceRefresh()

   403

        """

   404

        Return if point is over one contextual button of Viewer

   405

        @param x: X coordinate of point

   406

        @param y: Y coordinate of point

   407

        @return: contextual button where point is over

   408

        """

   411

                return button

   412

        return None

   413

   414

    def ExportGraph(self, item=None):

   415

        """

   416

        Export item(s) data to clipboard in CSV format

   417

        @param item: Item from which data to export, all items if None

   418

        (default None)

   419

        """

   420

        self.ParentWindow.CopyDataToClipboard(

   421

            [(item, [entry for entry in item.GetData()])

   422

             for item in (self.Items 

   423

                          if item is None 

   424

                          else [item])])

   425

   426

    def GetOnChangeSizeButton(self, height):

   427

        """

   428

        Function that generate callback function for change Viewer height to

   429

        pre-defined height button

   430

        @param height: Height that change Viewer to

   431

        @return: callback function

   432

        """

   434

            self.SetCanvasSize(200, height)

   438

        """

   439

        Function called when Viewer Export button is pressed

   440

        """

   441

        # Export data of every item in Viewer

   444

    def OnForceItemButton(self):

   445

        """

   446

        Function called when contextual menu Force button is pressed

   447

        """

   448

        # Open dialog for forcing item variable value 

   450

        # Close contextual menu

   453

    def OnReleaseItemButton(self):

   454

        """

   455

        Function called when contextual menu Release button is pressed

   456

        """

   457

        # Release item variable value 

   459

        # Close contextual menu

   463

        """

   464

        Function called when contextual menu Export button is pressed

   465

        """

   466

        # Export data of item variable

   468

        # Close contextual menu

   472

        """

   473

        Function called when contextual menu Remove button is pressed

   474

        """

   475

        # Remove item from Viewer

   478

        # Close contextual menu

   481

    def HandleCursorMove(self, event):

   482

        start_tick, end_tick = self.ParentWindow.GetRange()

   483

        cursor_tick = None

   484

        items = self.ItemsDict.values()

   485

        if self.GraphType == GRAPH_ORTHOGONAL:

   486

            x_data = items[0].GetData(start_tick, end_tick)

   487

            y_data = items[1].GetData(start_tick, end_tick)

   488

            if len(x_data) > 0 and len(y_data) > 0:

   489

                length = min(len(x_data), len(y_data))

   490

                d = numpy.sqrt((x_data[:length,1]-event.xdata) ** 2 + (y_data[:length,1]-event.ydata) ** 2)

   491

                cursor_tick = x_data[numpy.argmin(d), 0]