25

from types import TupleType

    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

    60

        if self.ParentControl is not None:

    61

            self.ParentControl.OnMouseDragging(x, y)

    62

        else:

    63

            self.ParentWindow.RefreshHighlight(x, y)

    80

            if self.ParentControl is not None:

   121

        self.ParentWindow.ResetHighlight()

   129

MILLISECOND = 1000000

   130

SECOND = 1000 * MILLISECOND

   131

MINUTE = 60 * SECOND

   132

HOUR = 60 * MINUTE

   133

DAY = 24 * HOUR

   134

   135

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

   136

RANGE_VALUES = \

   137

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

   138

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

   139

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

   140

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

   141

   142

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   143

   144

SCROLLBAR_UNIT = 10

   145

   146

#CANVAS_HIGHLIGHT_TYPES

   147

[HIGHLIGHT_NONE,

   148

 HIGHLIGHT_BEFORE,

   149

 HIGHLIGHT_AFTER,

   150

 HIGHLIGHT_LEFT,

   151

 HIGHLIGHT_RIGHT,

   152

 HIGHLIGHT_RESIZE] = range(6)

   153

   154

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

   155

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

   156

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

   157

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

   158

   159

#CANVAS_SIZE_TYPES

   160

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

   161

   162

DEFAULT_CANVAS_HEIGHT = 200.

   163

CANVAS_BORDER = (20., 10.)

   164

CANVAS_PADDING = 8.5

   165

VALUE_LABEL_HEIGHT = 17.

   166

AXES_LABEL_HEIGHT = 12.75

   167

   168

def compute_mask(x, y):

   169

    mask = []

   170

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

   171

        if xp == yp:

   172

            mask.append(xp)

   173

        else:

   174

            mask.append("*")

   175

    return mask

   176

   177

def NextTick(variables):

   178

    next_tick = None

   179

    for item, data in variables:

   180

        if len(data) > 0:

   181

            if next_tick is None:

   182

                next_tick = data[0][0]

   184

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

   185

    return next_tick

   186

   187

def OrthogonalData(item, start_tick, end_tick):

   188

    data = item.GetData(start_tick, end_tick)

   189

    min_value, max_value = item.GetValueRange()

   190

    if min_value is not None and max_value is not None:

   191

        center = (min_value + max_value) / 2.

   192

        range = max(1.0, max_value - min_value)

   193

    else:

   194

        center = 0.5

   195

        range = 1.0

   196

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

   197

   198

class GraphButton():

   199

   200

    def __init__(self, x, y, bitmap, callback):

   201

        self.Position = wx.Point(x, y)

   202

        self.Bitmap = bitmap

   203

        self.Shown = True

   204

        self.Enabled = True

   205

        self.Callback = callback

   206

   207

    def __del__(self):

   208

        self.callback = None

   209

   210

    def GetSize(self):

   211

        return self.Bitmap.GetSize()

   212

   213

    def SetPosition(self, x, y):

   214

        self.Position = wx.Point(x, y)

   215

   216

    def Show(self):

   217

        self.Shown = True

   218

   219

    def Hide(self):

   220

        self.Shown = False

   221

   222

    def IsShown(self):

   223

        return self.Shown

   224

   225

    def Enable(self):

   226

        self.Enabled = True

   227

   228

    def Disable(self):

   229

        self.Enabled = False

   230

   231

    def IsEnabled(self):

   232

        return self.Enabled

   233

   234

    def HitTest(self, x, y):

   235

        if self.Shown and self.Enabled:

   236

            w, h = self.Bitmap.GetSize()

   237

            rect = wx.Rect(self.Position.x, self.Position.y, w, h)

   238

            if rect.InsideXY(x, y):

   239

                return True

   240

        return False

   241

   242

    def ProcessCallback(self):

   243

        if self.Callback is not None:

   244

            wx.CallAfter(self.Callback)

   245

   246

    def Draw(self, dc):

   247

        if self.Shown and self.Enabled:

   248

            dc.DrawBitmap(self.Bitmap, self.Position.x, self.Position.y, True)

   249

   250

class DebugVariableViewer:

   251

   252

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

   253

        self.ParentWindow = window

   254

        self.Items = items

   255

   256

        self.Highlight = HIGHLIGHT_NONE

   257

        self.Buttons = []

   258

   259

    def __del__(self):

   260

        self.ParentWindow = None

   261

   262

    def GetIndex(self):

   263

        return self.ParentWindow.GetViewerIndex(self)

   264

   265

    def GetItem(self, variable):

   266

        for item in self.Items:

   267

            if item.GetVariable() == variable:

   268

                return item

   269

        return None

   270

   271

    def GetItems(self):

   272

        return self.Items

   273

   274

    def GetVariables(self):

   275

        if len(self.Items) > 1:

   276

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

   277

            if self.GraphType == GRAPH_ORTHOGONAL:

   278

                return tuple(variables)

   279

            return variables

   280

        return self.Items[0].GetVariable()

   281

   282

    def AddItem(self, item):

   283

        self.Items.append(item)

   284

   285

    def RemoveItem(self, item):

   286

        if item in self.Items:

   287

            self.Items.remove(item)

   288

   289

    def Clear(self):

   290

        for item in self.Items:

   291

            self.ParentWindow.RemoveDataConsumer(item)

   292

        self.Items = []

   293

   294

    def IsEmpty(self):

   295

        return len(self.Items) == 0

   296

   297

    def UnregisterObsoleteData(self):

   298

        for item in self.Items[:]:

   299

            iec_path = item.GetVariable()

   300

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

   301

                self.ParentWindow.RemoveDataConsumer(item)

   302

                self.RemoveItem(item)

   303

            else:

   304

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

   305

                item.RefreshVariableType()

   306

   307

    def ResetData(self):

   308

        for item in self.Items:

   309

            item.ResetData()

   310

   311

    def RefreshViewer(self):

   312

        pass

   313

   314

    def SetHighlight(self, highlight):

   315

        if self.Highlight != highlight:

   316

            self.Highlight = highlight

   317

            return True

   318

        return False

   319

   320

    def GetButtons(self):

   321

        return self.Buttons

   322

   323

    def HandleButtons(self, x, y):

   324

        for button in self.GetButtons():

   325

            if button.HitTest(x, y):

   326

                button.ProcessCallback()

   327

                return True

   328

        return False

   329

   330

    def IsOverButton(self, x, y):

   331

        for button in self.GetButtons():

   332

            if button.HitTest(x, y):

   333

                return True

   334

        return False

   335

   336

    def ShowButtons(self, show):

   337

        for button in self.Buttons:

   338

            if show:

   339

                button.Show()

   340

            else:

   341

                button.Hide()

   342

        self.RefreshButtonsState()

   343

        self.ParentWindow.ForceRefresh()

   344

   345

    def RefreshButtonsState(self, refresh_positions=False):

   346

        if self:

   347

            width, height = self.GetSize()

   348

            if refresh_positions:

   349

                offset = 0

   350

                buttons = self.Buttons[:]

   351

                buttons.reverse()

   352

                for button in buttons:

   353

                    w, h = button.GetSize()

   354

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

   355

                    offset += w + 2

   356

                self.ParentWindow.ForceRefresh()

   357

   358

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

   359

        width, height = self.GetSize()

   360

   361

        dc.SetPen(HIGHLIGHT_DROP_PEN)

   362

        dc.SetBrush(HIGHLIGHT_DROP_BRUSH)

   363

        if self.Highlight in [HIGHLIGHT_BEFORE]:

   364

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

   365

        elif self.Highlight in [HIGHLIGHT_AFTER]:

   366

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

   367

   368

        if buttons is None:

   369

            buttons = self.Buttons

   370

        for button in buttons:

   371

            button.Draw(dc)

   372

   373

        if self.ParentWindow.IsDragging():

   374

            destBBox = self.ParentWindow.GetDraggingAxesClippingRegion(self)

   375

            srcPos = self.ParentWindow.GetDraggingAxesPosition(self)

   376

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

   377

                srcPanel = self.ParentWindow.DraggingAxesPanel

   378

                srcBBox = srcPanel.GetAxesBoundingBox()

   379

   380

                if destBBox.x == 0:

   381

                    srcX = srcBBox.x - srcPos.x

   383

                    srcX = srcBBox.x

   384

                if destBBox.y == 0:

   385

                    srcY = srcBBox.y - srcPos.y

   386

                else:

   387

                    srcY = srcBBox.y

   388

   389

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

   390

                srcDC = wx.MemoryDC()

   391

                srcDC.SelectObject(srcBmp)

   392

   393

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

   394

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

   395

                        srcDC, srcX, srcY)

   396

   397

    def OnEnter(self, event):

   398

        self.ShowButtons(True)

   399

        event.Skip()

   400

   401

    def OnLeave(self, event):

   402

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

   403

            x, y = event.GetPosition()

   404

            width, height = self.GetSize()

   405

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

   406

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

   407

                self.ShowButtons(False)

   408

        event.Skip()

   409

   410

    def OnCloseButton(self):

   411

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

   412

   413

    def OnForceButton(self):

   414

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

   415

   416

    def OnReleaseButton(self):

   417

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

   418

   419

    def OnResizeWindow(self, event):

   420

        wx.CallAfter(self.RefreshButtonsState, True)

   421

        event.Skip()

   422

   423

    def OnMouseDragging(self, x, y):

   424

        xw, yw = self.GetPosition()

   425

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

   426

   427

    def OnDragging(self, x, y):

   428

        width, height = self.GetSize()

   429

        if y < height / 2:

   430

            if self.ParentWindow.IsViewerFirst(self):

   431

                self.SetHighlight(HIGHLIGHT_BEFORE)

   432

            else:

   433

                self.SetHighlight(HIGHLIGHT_NONE)

   434

                self.ParentWindow.HighlightPreviousViewer(self)

   435

        else:

   436

            self.SetHighlight(HIGHLIGHT_AFTER)

   437

   438

    def OnEraseBackground(self, event):

   439

        pass

   440

   441

    def OnResize(self, event):

   442

        wx.CallAfter(self.RefreshButtonsState, True)

   443

        event.Skip()

   444

   445

    def ForceValue(self, item):

   446

        iec_path = item.GetVariable()

   447

        iec_type = self.ParentWindow.GetDataType(iec_path)

   448

        if iec_type is not None:

   449

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

   450

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

   451

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

   452

   453

    def ReleaseValue(self, item):

   454

        iec_path = item.GetVariable().upper()

   455

        self.ParentWindow.ReleaseDataValue(iec_path)

   456

   457

   458

class DebugVariableText(DebugVariableViewer, wx.Panel):

   459

   460

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

   461

        DebugVariableViewer.__init__(self, window, items)

   462

   463

        wx.Panel.__init__(self, parent)

   464

        self.SetBackgroundColour(wx.WHITE)

   465

        self.SetDropTarget(DebugVariableDropTarget(window, self))

   466

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

   467

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

   468

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

   469

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

   470

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

   471

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

   472

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

   473

   474

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

   475

   476

        self.Buttons.append(

   477

            GraphButton(0, 0, GetBitmap("force"), self.OnForceButton))

   478

        self.Buttons.append(

   479

            GraphButton(0, 0, GetBitmap("release"), self.OnReleaseButton))

   480

        self.Buttons.append(

   481

            GraphButton(0, 0, GetBitmap("delete_graph"), self.OnCloseButton))

   482

   483

        self.ShowButtons(False)

   484

   485

    def RefreshViewer(self):

   486

        width, height = self.GetSize()

   487

        bitmap = wx.EmptyBitmap(width, height)

   488

   489

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

   490

        dc.Clear()

   491

        dc.BeginDrawing()

   492

   493

        gc = wx.GCDC(dc)

   494

   495

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

   496

        w, h = gc.GetTextExtent(item_name)

   497

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