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 __future__ import division

    28

from datetime import datetime

    29

from time import time as gettime

    30

from weakref import proxy

    31

    32

import numpy

    33

import wx

    34

from six.moves import xrange

    35

    36

from controls.CustomToolTip import CustomToolTip, TOOLTIP_WAIT_PERIOD

    37

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    38

from runtime.loglevels import LogLevelsCount, LogLevels

    39

from util.BitmapLibrary import GetBitmap

    40

    41

    42

THUMB_SIZE_RATIO = 1. / 8.

    43

    44

    45

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

    46

    if direction == wx.TOP:

    47

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

    48

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

    49

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

    50

    else:

    51

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

    52

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

    53

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

    54

    55

    56

class LogScrollBar(wx.Panel):

    57

    58

    def __init__(self, parent, size):

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

    67

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

    68

        self.ThumbScrollingStartPos = None

    69

    70

    def GetRangeRect(self):

    71

        width, height = self.GetClientSize()

    72

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

    73

    74

    def GetThumbRect(self):

    75

        width, _height = self.GetClientSize()

    76

        range_rect = self.GetRangeRect()

    77

        thumb_size = range_rect.height * THUMB_SIZE_RATIO

    78

        thumb_range = range_rect.height - thumb_size

    79

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

    80

        thumb_start = int(thumb_center_position - thumb_size / 2.)

    81

        thumb_end = int(thumb_center_position + thumb_size / 2.)

    82

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

    83

    84

    def RefreshThumbPosition(self, thumb_position=None):

    85

        if thumb_position is None:

    86

            thumb_position = self.ThumbPosition

    87

        if self.Parent.IsMessagePanelTop():

    88

            thumb_position = max(0., thumb_position)

    89

        if self.Parent.IsMessagePanelBottom():

    90

            thumb_position = min(0., thumb_position)

    91

        if thumb_position != self.ThumbPosition:

    92

            self.ThumbPosition = thumb_position

    93

            self.Parent.SetScrollSpeed(self.ThumbPosition)

    94

        self.Refresh()

    95

    96

    def OnLeftDown(self, event):

    97

        self.CaptureMouse()

    98

        posx, posy = event.GetPosition()

    99

        width, height = self.GetClientSize()

   100

        range_rect = self.GetRangeRect()

   101

        thumb_rect = self.GetThumbRect()

   102

        if range_rect.Contains(posx, posy):

   103

            if thumb_rect.Contains(posx, posy):

   104

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

   105

            elif posy < thumb_rect.y:

   106

                self.Parent.ScrollToLast()

   107

            elif posy > thumb_rect.y + thumb_rect.height:

   108

                self.Parent.ScrollToFirst()

   109

        elif posy < width:

   110

            self.Parent.ScrollMessagePanelByPage(1)

   111

        elif posy > height - width:

   112

            self.Parent.ScrollMessagePanelByPage(-1)

   113

        event.Skip()

   114

   115

    def OnLeftUp(self, event):

   116

        self.ThumbScrollingStartPos = None

   117

        self.RefreshThumbPosition(0.)

   118

        if self.HasCapture():

   119

            self.ReleaseMouse()

   120

        event.Skip()

   121

   122

    def OnMotion(self, event):

   123

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

   124

            _posx, posy = event.GetPosition()

   125

            range_rect = self.GetRangeRect()

   126

            thumb_size = range_rect.height * THUMB_SIZE_RATIO

   127

            thumb_range = range_rect.height - thumb_size

   128

            self.RefreshThumbPosition(

   129

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

   130

        event.Skip()

   131

   132

    def OnResize(self, event):

   133

        self.Refresh()

   134

        event.Skip()

   135

   136

    def OnEraseBackground(self, event):

   137

        pass

   138

   139

    def OnPaint(self, event):

   140

        dc = wx.BufferedPaintDC(self)

   141

        dc.Clear()

   142

   143

        gc = wx.GCDC(dc)

   144

   145

        width, height = self.GetClientSize()

   146

   147

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

   148

        gc.SetBrush(wx.GREY_BRUSH)

   149

   150

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

   151

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

   152

   153

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

   154

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

   155

   156

        thumb_rect = self.GetThumbRect()

   157

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

   158

                                 thumb_rect.width, thumb_rect.height)

   159

        if self.Parent.IsMessagePanelTop():

   160

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

   161

        if self.Parent.IsMessagePanelBottom():

   162

            exclusion_rect.height = height - width - exclusion_rect.y

   163

        if exclusion_rect != thumb_rect:

   164

            colour = wx.NamedColour("LIGHT GREY")

   165

            gc.SetPen(wx.Pen(colour))

   166

            gc.SetBrush(wx.Brush(colour))

   167

   168

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

   169

                             exclusion_rect.width, exclusion_rect.height)

   170

   171

        gc.SetPen(wx.GREY_PEN)

   172

        gc.SetBrush(wx.GREY_BRUSH)

   173

   174

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

   175

   176

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

   177

   178

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

   179

                         thumb_rect.width, thumb_rect.height)

   180

   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.Contains(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.Add(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.Add(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.Add(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.SetToolTip(_("Clean log messages"))

   328

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

   329

        filter_sizer.Add(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.Add(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='FreeMono')

   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.Add(self.MessagePanel, flag=wx.GROW)

   351

   352

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

   353

        message_panel_sizer.Add(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