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

from __future__ import absolute_import

    27

from datetime import datetime

    28

from time import time as gettime

    29

from weakref import proxy

    30

    31

import numpy

    32

import wx

    33

    34

from controls.CustomToolTip import CustomToolTip, TOOLTIP_WAIT_PERIOD

    35

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    36

from runtime.loglevels import LogLevelsCount, LogLevels

    37

from util.BitmapLibrary import GetBitmap

    38

    39

    40

THUMB_SIZE_RATIO = 1. / 8.

    41

    42

    43

def ArrowPoints(direction, width, height, xoffset, yoffset):

    44

    if direction == wx.TOP:

    45

        return [wx.Point(xoffset + 1, yoffset + height - 2),

    46

                wx.Point(xoffset + width / 2, yoffset + 1),

    47

                wx.Point(xoffset + width - 1, yoffset + height - 2)]

    48

    else:

    49

        return [wx.Point(xoffset + 1, yoffset - height + 1),

    50

                wx.Point(xoffset + width / 2, yoffset - 2),

    51

                wx.Point(xoffset + width - 1, yoffset - height + 1)]

    52

    53

    54

class LogScrollBar(wx.Panel):

    55

    56

    def __init__(self, parent, size):

    57

        wx.Panel.__init__(self, parent, size=size)

    58

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

    59

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

    60

        self.Bind(wx.EVT_MOTION, self.OnMotion)

    61

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

    62

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

    63

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

    64

    65

        self.ThumbPosition = 0.  # -1 <= ThumbPosition <= 1

    66

        self.ThumbScrollingStartPos = None

    67

    68

    def GetRangeRect(self):

    69

        width, height = self.GetClientSize()

    70

        return wx.Rect(0, width, width, height - 2 * width)

    71

    72

    def GetThumbRect(self):

    73

        width, _height = self.GetClientSize()

    74

        range_rect = self.GetRangeRect()

    75

        thumb_size = range_rect.height * THUMB_SIZE_RATIO

    76

        thumb_range = range_rect.height - thumb_size

    77

        thumb_center_position = (thumb_size + (self.ThumbPosition + 1) * thumb_range) / 2.

    78

        thumb_start = int(thumb_center_position - thumb_size / 2.)

    79

        thumb_end = int(thumb_center_position + thumb_size / 2.)

    80

        return wx.Rect(0, range_rect.y + thumb_start, width, thumb_end - thumb_start)

    81

    82

    def RefreshThumbPosition(self, thumb_position=None):

    83

        if thumb_position is None:

    84

            thumb_position = self.ThumbPosition

    85

        if self.Parent.IsMessagePanelTop():

    86

            thumb_position = max(0., thumb_position)

    87

        if self.Parent.IsMessagePanelBottom():

    88

            thumb_position = min(0., thumb_position)

    89

        if thumb_position != self.ThumbPosition:

    90

            self.ThumbPosition = thumb_position

    91

            self.Parent.SetScrollSpeed(self.ThumbPosition)

    92

        self.Refresh()

    93

    94

    def OnLeftDown(self, event):

    95

        self.CaptureMouse()

    96

        posx, posy = event.GetPosition()

    97

        width, height = self.GetClientSize()

    98

        range_rect = self.GetRangeRect()

    99

        thumb_rect = self.GetThumbRect()

   100

        if range_rect.InsideXY(posx, posy):

   101

            if thumb_rect.InsideXY(posx, posy):

   102

                self.ThumbScrollingStartPos = wx.Point(posx, posy)

   103

            elif posy < thumb_rect.y:

   104

                self.Parent.ScrollToLast()

   105

            elif posy > thumb_rect.y + thumb_rect.height:

   106

                self.Parent.ScrollToFirst()

   107

        elif posy < width:

   108

            self.Parent.ScrollMessagePanelByPage(1)

   109

        elif posy > height - width:

   110

            self.Parent.ScrollMessagePanelByPage(-1)

   111

        event.Skip()

   112

   113

    def OnLeftUp(self, event):

   114

        self.ThumbScrollingStartPos = None

   115

        self.RefreshThumbPosition(0.)

   116

        if self.HasCapture():

   117

            self.ReleaseMouse()

   118

        event.Skip()

   119

   120

    def OnMotion(self, event):

   121

        if event.Dragging() and self.ThumbScrollingStartPos is not None:

   122

            _posx, posy = event.GetPosition()

   123

            range_rect = self.GetRangeRect()

   124

            thumb_size = range_rect.height * THUMB_SIZE_RATIO

   125

            thumb_range = range_rect.height - thumb_size

   126

            self.RefreshThumbPosition(

   127

                max(-1., min((posy - self.ThumbScrollingStartPos.y) * 2. / thumb_range, 1.)))

   128

        event.Skip()

   129

   130

    def OnResize(self, event):

   131

        self.Refresh()

   132

        event.Skip()

   133

   134

    def OnEraseBackground(self, event):

   135

        pass

   136

   137

    def OnPaint(self, event):

   138

        dc = wx.BufferedPaintDC(self)

   139

        dc.Clear()

   140

        dc.BeginDrawing()

   141

   142

        gc = wx.GCDC(dc)

   143

   144

        width, height = self.GetClientSize()

   145

   146

        gc.SetPen(wx.Pen(wx.NamedColour("GREY"), 3))

   147

        gc.SetBrush(wx.GREY_BRUSH)

   148

   149

        gc.DrawLines(ArrowPoints(wx.TOP, width * 0.75, width * 0.5, 2, (width + height) / 4 - 3))

   150

        gc.DrawLines(ArrowPoints(wx.TOP, width * 0.75, width * 0.5, 2, (width + height) / 4 + 3))

   151

   152

        gc.DrawLines(ArrowPoints(wx.BOTTOM, width * 0.75, width * 0.5, 2, (height * 3 - width) / 4 + 3))

   153

        gc.DrawLines(ArrowPoints(wx.BOTTOM, width * 0.75, width * 0.5, 2, (height * 3 - width) / 4 - 3))

   154

   155

        thumb_rect = self.GetThumbRect()

   156

        exclusion_rect = wx.Rect(thumb_rect.x, thumb_rect.y,

   157

                                 thumb_rect.width, thumb_rect.height)

   158

        if self.Parent.IsMessagePanelTop():

   159

            exclusion_rect.y, exclusion_rect.height = width, exclusion_rect.y + exclusion_rect.height - width

   160

        if self.Parent.IsMessagePanelBottom():

   161

            exclusion_rect.height = height - width - exclusion_rect.y

   162

        if exclusion_rect != thumb_rect:

   163

            colour = wx.NamedColour("LIGHT GREY")

   164

            gc.SetPen(wx.Pen(colour))

   165

            gc.SetBrush(wx.Brush(colour))

   166

   167

            gc.DrawRectangle(exclusion_rect.x, exclusion_rect.y,

   168

                             exclusion_rect.width, exclusion_rect.height)

   169

   170

        gc.SetPen(wx.GREY_PEN)

   171

        gc.SetBrush(wx.GREY_BRUSH)

   172

   173

        gc.DrawPolygon(ArrowPoints(wx.TOP, width, width, 0, 0))

   174

   175

        gc.DrawPolygon(ArrowPoints(wx.BOTTOM, width, width, 0, height))

   176

   177

        gc.DrawRectangle(thumb_rect.x, thumb_rect.y,

   178

                         thumb_rect.width, thumb_rect.height)

   179

   180

        dc.EndDrawing()

   181

        event.Skip()

   182

   183

   184

BUTTON_SIZE = (70, 15)

   185

   186

   187

class LogButton(object):

   188

   189

    def __init__(self, label, callback):

   190

        self.Position = wx.Point(0, 0)

   191

        self.Size = wx.Size(*BUTTON_SIZE)

   192

        self.Label = label

   193

        self.Shown = True

   194

        self.Callback = callback

   195

   196

    def __del__(self):

   197

        self.callback = None

   198

   199

    def GetSize(self):

   200

        return self.Size

   201

   202

    def SetPosition(self, x, y):

   203

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

   204

   205

    def HitTest(self, x, y):

   206

        rect = wx.Rect(self.Position.x, self.Position.y,

   207

                       self.Size.width, self.Size.height)

   208

        if rect.InsideXY(x, y):

   209

            return True

   210

        return False

   211

   212

    def ProcessCallback(self):

   213

        if self.Callback is not None:

   214

            wx.CallAfter(self.Callback)

   215

   216

    def Draw(self, dc):

   217

        dc.SetPen(wx.TRANSPARENT_PEN)

   218

        dc.SetBrush(wx.Brush(wx.NamedColour("LIGHT GREY")))

   219

   220

        dc.DrawRectangle(self.Position.x, self.Position.y,

   221

                         self.Size.width, self.Size.height)

   222

   223

        w, h = dc.GetTextExtent(self.Label)

   224

        dc.DrawText(self.Label,

   225

                    self.Position.x + (self.Size.width - w) / 2,

   226

                    self.Position.y + (self.Size.height - h) / 2)

   227

   228

   229

DATE_INFO_SIZE = 10

   230

MESSAGE_INFO_SIZE = 18

   231

   232

   233

class LogMessage(object):

   234

   235

    def __init__(self, tv_sec, tv_nsec, level, level_bitmap, msg):

   236

        self.Date = datetime.utcfromtimestamp(tv_sec)

   237

        self.Seconds = self.Date.second + tv_nsec * 1e-9

   238

        self.Date = self.Date.replace(second=0)

   239

        self.Timestamp = tv_sec + tv_nsec * 1e-9

   240

        self.Level = level

   241

        self.LevelBitmap = level_bitmap

   242

        self.Message = msg

   243

        self.DrawDate = True

   244

   245

    def __cmp__(self, other):

   246

        if self.Date == other.Date:

   247

            return cmp(self.Seconds, other.Seconds)

   248

        return cmp(self.Date, other.Date)

   249

   250

    def GetFullText(self):

   251

        date = self.Date.replace(second=int(self.Seconds))

   252

        nsec = (self.Seconds % 1.) * 1e9

   253

        return "%s at %s.%9.9d:\n%s" % (

   254

            LogLevels[self.Level],

   255

            str(date), nsec,

   256

            self.Message)

   257

   258

    def Draw(self, dc, offset, width, draw_date):

   259

        if draw_date:

   260

            datetime_text = self.Date.strftime("%d/%m/%y %H:%M")

   261

            dw, dh = dc.GetTextExtent(datetime_text)

   262

            dc.DrawText(datetime_text, (width - dw) / 2, offset + (DATE_INFO_SIZE - dh) / 2)

   263

            offset += DATE_INFO_SIZE

   264

   265

        seconds_text = "%12.9f" % self.Seconds

   266

        sw, sh = dc.GetTextExtent(seconds_text)

   267

        dc.DrawText(seconds_text, 5, offset + (MESSAGE_INFO_SIZE - sh) / 2)

   268

   269

        bw, bh = self.LevelBitmap.GetWidth(), self.LevelBitmap.GetHeight()

   270

        dc.DrawBitmap(self.LevelBitmap, 10 + sw, offset + (MESSAGE_INFO_SIZE - bh) / 2)

   271

   272

        text = self.Message.replace("\n", " ")

   273

        _mw, mh = dc.GetTextExtent(text)

   274

        dc.DrawText(text, 15 + sw + bw, offset + (MESSAGE_INFO_SIZE - mh) / 2)

   275

   276

    def GetHeight(self, draw_date):

   277

        if draw_date:

   278

            return DATE_INFO_SIZE + MESSAGE_INFO_SIZE

   279

        return MESSAGE_INFO_SIZE

   280

   281

   282

SECOND = 1

   283

MINUTE = 60 * SECOND

   284

HOUR = 60 * MINUTE

   285

DAY = 24 * HOUR

   286

   287

CHANGE_TIMESTAMP_BUTTONS = [(_("1d"), DAY),

   288

                            (_("1h"), HOUR),

   289

                            (_("1m"), MINUTE),

   290

                            (_("1s"), SECOND)]

   291

   292

   293

class LogViewer(DebugViewer, wx.Panel):

   294

   295

    def __init__(self, parent, window):

   296

        wx.Panel.__init__(self, parent, style=wx.TAB_TRAVERSAL | wx.SUNKEN_BORDER)

   297

        DebugViewer.__init__(self, None, False, False)

   298

   299

        main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)

   300

        main_sizer.AddGrowableCol(0)

   301

        main_sizer.AddGrowableRow(1)

   302

   303

        filter_sizer = wx.BoxSizer(wx.HORIZONTAL)

   304

        main_sizer.AddSizer(filter_sizer, border=5, flag=wx.TOP | wx.LEFT | wx.RIGHT | wx.GROW)

   305

   306

        self.MessageFilter = wx.ComboBox(self, style=wx.CB_READONLY)

   307

        self.MessageFilter.Append(_("All"))

   308

        levels = LogLevels[:3]

   309

        levels.reverse()

   310

        for level in levels:

   311

            self.MessageFilter.Append(_(level))

   312

        self.Bind(wx.EVT_COMBOBOX, self.OnMessageFilterChanged, self.MessageFilter)

   313

        filter_sizer.AddWindow(self.MessageFilter, 1, border=5, flag=wx.RIGHT | wx.ALIGN_CENTER_VERTICAL)

   314

   315

        self.SearchMessage = wx.SearchCtrl(self, style=wx.TE_PROCESS_ENTER)

   316

        self.SearchMessage.ShowSearchButton(True)

   317

        self.SearchMessage.ShowCancelButton(True)

   318

        self.Bind(wx.EVT_TEXT_ENTER, self.OnSearchMessageChanged, self.SearchMessage)

   319

        self.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN,

   320

                  self.OnSearchMessageSearchButtonClick, self.SearchMessage)

   321

        self.Bind(wx.EVT_SEARCHCTRL_CANCEL_BTN,

   322

                  self.OnSearchMessageCancelButtonClick, self.SearchMessage)

   323

        filter_sizer.AddWindow(self.SearchMessage, 3, border=5, flag=wx.RIGHT | wx.ALIGN_CENTER_VERTICAL)

   324

   325

        self.CleanButton = wx.lib.buttons.GenBitmapButton(self, bitmap=GetBitmap("Clean"),

   326

                                                          size=wx.Size(28, 28), style=wx.NO_BORDER)

   327

        self.CleanButton.SetToolTipString(_("Clean log messages"))

   328

        self.Bind(wx.EVT_BUTTON, self.OnCleanButton, self.CleanButton)

   329

        filter_sizer.AddWindow(self.CleanButton)

   330

   331

        message_panel_sizer = wx.FlexGridSizer(cols=2, hgap=0, rows=1, vgap=0)

   332

        message_panel_sizer.AddGrowableCol(0)

   333

        message_panel_sizer.AddGrowableRow(0)

   334

        main_sizer.AddSizer(message_panel_sizer, border=5, flag=wx.LEFT | wx.RIGHT | wx.BOTTOM | wx.GROW)

   335

   336

        self.MessagePanel = wx.Panel(self)

   337

        if wx.Platform == '__WXMSW__':

   338

            self.Font = wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL, faceName='Courier New')

   339

        else:

   340

            self.Font = wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL, faceName='Courier')

   341

        self.MessagePanel.Bind(wx.EVT_LEFT_UP, self.OnMessagePanelLeftUp)

   342

        self.MessagePanel.Bind(wx.EVT_RIGHT_UP, self.OnMessagePanelRightUp)

   343

        self.MessagePanel.Bind(wx.EVT_LEFT_DCLICK, self.OnMessagePanelLeftDCLick)

   344

        self.MessagePanel.Bind(wx.EVT_MOTION, self.OnMessagePanelMotion)

   345

        self.MessagePanel.Bind(wx.EVT_LEAVE_WINDOW, self.OnMessagePanelLeaveWindow)

   346

        self.MessagePanel.Bind(wx.EVT_MOUSEWHEEL, self.OnMessagePanelMouseWheel)

   347

        self.MessagePanel.Bind(wx.EVT_ERASE_BACKGROUND, self.OnMessagePanelEraseBackground)

   348

        self.MessagePanel.Bind(wx.EVT_PAINT, self.OnMessagePanelPaint)

   349

        self.MessagePanel.Bind(wx.EVT_SIZE, self.OnMessagePanelResize)

   350

        message_panel_sizer.AddWindow(self.MessagePanel, flag=wx.GROW)

   351

   352

        self.MessageScrollBar = LogScrollBar(self, wx.Size(16, -1))

   353

        message_panel_sizer.AddWindow(self.MessageScrollBar, flag=wx.GROW)

   354

   355

        self.SetSizer(main_sizer)

   356

   357

        self.LeftButtons = []

   358

        for label, callback in [("+" + text, self.GenerateOnDurationButton(duration))

   359

                                for text, duration in CHANGE_TIMESTAMP_BUTTONS]:

   360

            self.LeftButtons.append(LogButton(label, callback))

   361

   362

        self.RightButtons = []

   363

        for label, callback in [("-" + text, self.GenerateOnDurationButton(-duration))

   364

                                for text, duration in CHANGE_TIMESTAMP_BUTTONS]:

   365

            self.RightButtons.append(LogButton(label, callback))

   366

   367

        self.MessageFilter.SetSelection(0)

   368

        self.LogSource = None

   369

        self.ResetLogMessages()

   370

        self.ParentWindow = window

   371

   372

        self.LevelIcons = [GetBitmap("LOG_" + level) for level in LogLevels]

   373

        self.LevelFilters = [range(i) for i in xrange(4, 0, -1)]

   374

        self.CurrentFilter = self.LevelFilters[0]

   375

        self.CurrentSearchValue = ""

   376

   377

        self.ScrollSpeed = 0.

   378

        self.LastStartTime = None

   379

        self.ScrollTimer = wx.Timer(self, -1)

   380

        self.Bind(wx.EVT_TIMER, self.OnScrollTimer, self.ScrollTimer)

   381

   382

        self.LastMousePos = None

   383

        self.MessageToolTip = None

   384

        self.MessageToolTipTimer = wx.Timer(self, -1)

   385

        self.Bind(wx.EVT_TIMER, self.OnMessageToolTipTimer, self.MessageToolTipTimer)

   386

   387

    def __del__(self):

   388

        self.ScrollTimer.Stop()

   389

   390

    def ResetLogMessages(self):

   391

        self.ResetLogCounters()

   392

        self.OldestMessages = []

   393

        self.LogMessages = []

   394

        self.LogMessagesTimestamp = numpy.array([])

   395

        self.CurrentMessage = None

   396

        self.HasNewData = False

   397

   398

    def SetLogSource(self, log_source):

   399

        self.LogSource = proxy(log_source) if log_source is not None else None

   400

        self.CleanButton.Enable(self.LogSource is not None)

   401

        if log_source is not None:

   402

            self.ResetLogMessages()

   403

            wx.CallAfter(self.RefreshView)

   404

   405

    def GetLogMessageFromSource(self, msgidx, level):

   406

        if self.LogSource is not None:

   407

            answer = self.LogSource.GetLogMessage(level, msgidx)

   408

            if answer is not None:

   409

                msg, _tick, tv_sec, tv_nsec = answer

   410

                return LogMessage(tv_sec, tv_nsec, level, self.LevelIcons[level], msg)

   411

        return None

   412

   413

    def ResetLogCounters(self):

   414

        self.previous_log_count = [None]*LogLevelsCount

   415

   416

    def SetLogCounters(self, log_count):

   417

        new_messages = []

   418

        for level, count, prev in zip(xrange(LogLevelsCount), log_count, self.previous_log_count):

   419

            if count is not None and prev != count:

   420

                if prev is None:

   421

                    dump_end = max(-1, count - 10)

   422

                    oldest_message = (-1, None)

   423

                else:

   424

                    dump_end = prev - 1

   425

                for msgidx in xrange(count-1, dump_end, -1):

   426

                    new_message = self.GetLogMessageFromSource(msgidx, level)

   427

                    if new_message is None:

   428

                        if prev is None:

   429

                            oldest_message = (-1, None)

   430

                        break

   431

                    if prev is None:

   432

                        oldest_message = (msgidx, new_message)

   433

                        if len(new_messages) == 0:

   434

                            new_messages = [new_message]

   435

                        else:

   436

                            new_messages.insert(0, new_message)

   437

                    else:

   438

                        new_messages.insert(0, new_message)

   439

                if prev is None and len(self.OldestMessages) <= level:

   440

                    self.OldestMessages.append(oldest_message)

   441

                self.previous_log_count[level] = count

   442

        new_messages.sort()

   443

        if len(new_messages) > 0:

   444

            self.HasNewData = True

   445

            if self.CurrentMessage is not None:

   446

                current_is_last = self.GetNextMessage(self.CurrentMessage)[0] is None

   447

            else:

   448

                current_is_last = True

   449

            for new_message in new_messages:

   450

                self.LogMessages.append(new_message)

   451

                self.LogMessagesTimestamp = numpy.append(self.LogMessagesTimestamp, [new_message.Timestamp])

   452

            if current_is_last:

   453

                self.ScrollToLast(False)

   454

                self.ResetMessageToolTip()

   455

                self.MessageToolTipTimer.Stop()

   456

                self.ParentWindow.SelectTab(self)

   457

            self.NewDataAvailable(None)

   458

   459

    def FilterLogMessage(self, message, timestamp=None):

   460

        return (message.Level in self.CurrentFilter and

   461

                message.Message.find(self.CurrentSearchValue) != -1 and

   462

                (timestamp is None or message.Timestamp < timestamp))

   463

   464

    def GetMessageByTimestamp(self, timestamp):

   465

        if self.CurrentMessage is not None:

   466

            msgidx = numpy.argmin(abs(self.LogMessagesTimestamp - timestamp))

   467

            message = self.LogMessages[msgidx]

   468

            if self.FilterLogMessage(message) and message.Timestamp > timestamp:

   469

                return self.GetPreviousMessage(msgidx, timestamp)

   470

            return message, msgidx

   471

        return None, None

   472

   473

    def GetNextMessage(self, msgidx):

   474

        while msgidx < len(self.LogMessages) - 1:

   475

            message = self.LogMessages[msgidx + 1]

   476

            if self.FilterLogMessage(message):

   477

                return message, msgidx + 1

   478

            msgidx += 1

   479

        return None, None

   480

   481

    def GetPreviousMessage(self, msgidx, timestamp=None):

   482

        message = None

   483

        while 0 < msgidx < len(self.LogMessages):

   484

            message = self.LogMessages[msgidx - 1]

   485

            if self.FilterLogMessage(message, timestamp):

   486

                return message, msgidx - 1

   487

            msgidx -= 1

   488

        if len(self.LogMessages) > 0:

   489

            message = self.LogMessages[0]