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

from six.moves import xrange

    34

    35

from controls.CustomToolTip import CustomToolTip, TOOLTIP_WAIT_PERIOD

    36

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    37

from runtime.loglevels import LogLevelsCount, LogLevels

    38

from util.BitmapLibrary import GetBitmap

    39

    40

    41

THUMB_SIZE_RATIO = 1. / 8.

    42

    43

    44

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

    45

    if direction == wx.TOP:

    46

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

    47

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

    48

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

    49

    else:

    50

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

    51

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

    52

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

    53

    54

    55

class LogScrollBar(wx.Panel):

    56

    57

    def __init__(self, parent, size):

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

    66

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

    67

        self.ThumbScrollingStartPos = None

    68

    69

    def GetRangeRect(self):

    70

        width, height = self.GetClientSize()

    71

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

    72

    73

    def GetThumbRect(self):

    74

        width, _height = self.GetClientSize()

    75

        range_rect = self.GetRangeRect()

    76

        thumb_size = range_rect.height * THUMB_SIZE_RATIO

    77

        thumb_range = range_rect.height - thumb_size

    78

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

    79

        thumb_start = int(thumb_center_position - thumb_size / 2.)

    80

        thumb_end = int(thumb_center_position + thumb_size / 2.)

    81

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

    82

    83

    def RefreshThumbPosition(self, thumb_position=None):

    84

        if thumb_position is None:

    85

            thumb_position = self.ThumbPosition

    86

        if self.Parent.IsMessagePanelTop():

    87

            thumb_position = max(0., thumb_position)

    88

        if self.Parent.IsMessagePanelBottom():

    89

            thumb_position = min(0., thumb_position)

    90

        if thumb_position != self.ThumbPosition:

    91

            self.ThumbPosition = thumb_position

    92

            self.Parent.SetScrollSpeed(self.ThumbPosition)

    93

        self.Refresh()

    94

    95

    def OnLeftDown(self, event):

    96

        self.CaptureMouse()

    97

        posx, posy = event.GetPosition()

    98

        width, height = self.GetClientSize()

    99

        range_rect = self.GetRangeRect()

   100

        thumb_rect = self.GetThumbRect()

   101

        if range_rect.InsideXY(posx, posy):

   102

            if thumb_rect.InsideXY(posx, posy):

   103

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

   104

            elif posy < thumb_rect.y:

   105

                self.Parent.ScrollToLast()

   106

            elif posy > thumb_rect.y + thumb_rect.height:

   107

                self.Parent.ScrollToFirst()

   108

        elif posy < width:

   109

            self.Parent.ScrollMessagePanelByPage(1)

   110

        elif posy > height - width:

   111

            self.Parent.ScrollMessagePanelByPage(-1)

   112

        event.Skip()

   113

   114

    def OnLeftUp(self, event):

   115

        self.ThumbScrollingStartPos = None

   116

        self.RefreshThumbPosition(0.)

   117

        if self.HasCapture():

   118

            self.ReleaseMouse()

   119

        event.Skip()

   120

   121

    def OnMotion(self, event):

   122

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

   123

            _posx, posy = event.GetPosition()

   124

            range_rect = self.GetRangeRect()

   125

            thumb_size = range_rect.height * THUMB_SIZE_RATIO

   126

            thumb_range = range_rect.height - thumb_size

   127

            self.RefreshThumbPosition(

   128

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

   129

        event.Skip()

   130

   131

    def OnResize(self, event):

   132

        self.Refresh()

   133

        event.Skip()

   134

   135

    def OnEraseBackground(self, event):

   136

        pass

   137

   138

    def OnPaint(self, event):

   139

        dc = wx.BufferedPaintDC(self)

   140

        dc.Clear()

   141

        dc.BeginDrawing()

   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

        dc.EndDrawing()

   182

        event.Skip()

   183

   184

   185

BUTTON_SIZE = (70, 15)

   186

   187

   188

class LogButton(object):

   189

   190

    def __init__(self, label, callback):

   191

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

   192

        self.Size = wx.Size(*BUTTON_SIZE)

   193

        self.Label = label

   194

        self.Shown = True

   195

        self.Callback = callback

   196

   197

    def __del__(self):

   198

        self.callback = None

   199

   200

    def GetSize(self):

   201

        return self.Size

   202

   203

    def SetPosition(self, x, y):

   204

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

   205

   206

    def HitTest(self, x, y):

   207

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

   208

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

   209

        if rect.InsideXY(x, y):

   210

            return True

   211

        return False

   212

   213

    def ProcessCallback(self):

   214

        if self.Callback is not None:

   215

            wx.CallAfter(self.Callback)

   216

   217

    def Draw(self, dc):

   218

        dc.SetPen(wx.TRANSPARENT_PEN)

   219

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

   220

   221

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

   222

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

   223

   224

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

   225

        dc.DrawText(self.Label,

   226

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

   227

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

   228

   229

   230

DATE_INFO_SIZE = 10

   231

MESSAGE_INFO_SIZE = 18

   232

   233

   234

class LogMessage(object):

   235

   236

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

   237

        self.Date = datetime.utcfromtimestamp(tv_sec)

   238

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

   239

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

   240

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

   241

        self.Level = level

   242

        self.LevelBitmap = level_bitmap

   243

        self.Message = msg

   244

        self.DrawDate = True

   245

   246

    def __cmp__(self, other):

   247

        if self.Date == other.Date:

   248

            return cmp(self.Seconds, other.Seconds)

   249

        return cmp(self.Date, other.Date)

   250

   251

    def GetFullText(self):

   252

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

   253

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

   254

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

   255

            LogLevels[self.Level],

   256

            str(date), nsec,

   257

            self.Message)

   258

   259

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

   260

        if draw_date:

   261

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

   262

            dw, dh = dc.GetTextExtent(datetime_text)

   263

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

   264

            offset += DATE_INFO_SIZE

   265

   266

        seconds_text = "%12.9f" % self.Seconds

   267

        sw, sh = dc.GetTextExtent(seconds_text)

   268

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

   269

   270

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

   271

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

   272

   273

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

   274

        _mw, mh = dc.GetTextExtent(text)

   275

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

   276

   277

    def GetHeight(self, draw_date):

   278

        if draw_date:

   279

            return DATE_INFO_SIZE + MESSAGE_INFO_SIZE

   280

        return MESSAGE_INFO_SIZE

   281

   282

   283

SECOND = 1

   284

MINUTE = 60 * SECOND

   285

HOUR = 60 * MINUTE

   286

DAY = 24 * HOUR

   287

   288

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

   289

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

   290

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

   291

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

   292

   293

   294

class LogViewer(DebugViewer, wx.Panel):

   295

   296

    def __init__(self, parent, window):

   297

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

   298

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

   299

   300

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

   301

        main_sizer.AddGrowableCol(0)

   302

        main_sizer.AddGrowableRow(1)

   303

   304

        filter_sizer = wx.BoxSizer(wx.HORIZONTAL)

   305

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

   306

   307

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

   308

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

   309

        levels = LogLevels[:3]

   310

        levels.reverse()

   311

        for level in levels:

   312

            self.MessageFilter.Append(_(level))

   313

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

   314

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

   315

   316

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

   317

        self.SearchMessage.ShowSearchButton(True)

   318

        self.SearchMessage.ShowCancelButton(True)

   319

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

   320

        self.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN,

   321

                  self.OnSearchMessageSearchButtonClick, self.SearchMessage)

   322

        self.Bind(wx.EVT_SEARCHCTRL_CANCEL_BTN,

   323

                  self.OnSearchMessageCancelButtonClick, self.SearchMessage)

   324

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

   325

   326

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

   327

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

   328

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

   329

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

   330

        filter_sizer.AddWindow(self.CleanButton)

   331

   332

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

   333

        message_panel_sizer.AddGrowableCol(0)

   334

        message_panel_sizer.AddGrowableRow(0)

   335

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

   336

   337

        self.MessagePanel = wx.Panel(self)

   338

        if wx.Platform == '__WXMSW__':

   339

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

   340

        else:

   341

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

   342

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

   343

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

   344

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

   345

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

   346

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

   347

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

   348

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

   349

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

   350

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

   351

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

   352

   353

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

   354

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

   355

   356

        self.SetSizer(main_sizer)

   357

   358

        self.LeftButtons = []

   359

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

   360

                                for text, duration in CHANGE_TIMESTAMP_BUTTONS]:

   361

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

   362

   363

        self.RightButtons = []

   364

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

   365

                                for text, duration in CHANGE_TIMESTAMP_BUTTONS]:

   366

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

   367

   368

        self.MessageFilter.SetSelection(0)

   369

        self.LogSource = None

   370

        self.ResetLogMessages()

   371

        self.ParentWindow = window

   372

   373

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

   374

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

   375

        self.CurrentFilter = self.LevelFilters[0]

   376

        self.CurrentSearchValue = ""

   377

   378

        self.ScrollSpeed = 0.

   379

        self.LastStartTime = None

   380

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

   381

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

   382

   383

        self.LastMousePos = None

   384

        self.MessageToolTip = None

   385

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

   386

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

   387

   388

    def __del__(self):

   389

        self.ScrollTimer.Stop()

   390

   391

    def ResetLogMessages(self):

   392

        self.ResetLogCounters()

   393

        self.OldestMessages = []

   394

        self.LogMessages = []

   395

        self.LogMessagesTimestamp = numpy.array([])

   396

        self.CurrentMessage = None

   397

        self.HasNewData = False

   398

   399

    def SetLogSource(self, log_source):

   400

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

   401

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

   402

        if log_source is not None:

   403

            self.ResetLogMessages()

   404

            wx.CallAfter(self.RefreshView)

   405

   406

    def GetLogMessageFromSource(self, msgidx, level):

   407

        if self.LogSource is not None:

   408

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

   409

            if answer is not None:

   410

                msg, _tick, tv_sec, tv_nsec = answer

   411

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

   412

        return None

   413

   414

    def ResetLogCounters(self):

   415

        self.previous_log_count = [None]*LogLevelsCount

   416

   417

    def SetLogCounters(self, log_count):

   418

        new_messages = []

   419

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

   420

            if count is not None and prev != count:

   421

                if prev is None:

   422

                    dump_end = max(-1, count - 10)

   423

                    oldest_message = (-1, None)

   424

                else:

   425

                    dump_end = prev - 1

   426

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

   427

                    new_message = self.GetLogMessageFromSource(msgidx, level)

   428

                    if new_message is None:

   429

                        if prev is None:

   430

                            oldest_message = (-1, None)

   431

                        break

   432

                    if prev is None:

   433

                        oldest_message = (msgidx, new_message)

   434

                        if len(new_messages) == 0:

   435

                            new_messages = [new_message]

   436

                        else:

   437

                            new_messages.insert(0, new_message)

   438

                    else:

   439

                        new_messages.insert(0, new_message)

   440

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

   441

                    self.OldestMessages.append(oldest_message)

   442

                self.previous_log_count[level] = count

   443

        new_messages.sort()

   444

        if len(new_messages) > 0:

   445

            self.HasNewData = True

   446

            if self.CurrentMessage is not None:

   447

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

   448

            else:

   449

                current_is_last = True

   450

            for new_message in new_messages:

   451

                self.LogMessages.append(new_message)

   452

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

   453

            if current_is_last:

   454

                self.ScrollToLast(False)

   455

                self.ResetMessageToolTip()

   456

                self.MessageToolTipTimer.Stop()

   457

                self.ParentWindow.SelectTab(self)

   458

            self.NewDataAvailable(None)

   459

   460

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

   461

        return (message.Level in self.CurrentFilter and

   462

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

   463

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

   464

   465

    def GetMessageByTimestamp(self, timestamp):

   466

        if self.CurrentMessage is not None:

   467

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

   468

            message = self.LogMessages[msgidx]

   469

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

   470

                return self.GetPreviousMessage(msgidx, timestamp)

   471

            return message, msgidx

   472

        return None, None

   473

   474

    def GetNextMessage(self, msgidx):

   475

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

   476

            message = self.LogMessages[msgidx + 1]

   477

            if self.FilterLogMessage(message):

   478

                return message, msgidx + 1

   479

            msgidx += 1

   480

        return None, None

   481

   482

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

   483

        message = None

   484

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

   485

            message = self.LogMessages[msgidx - 1]

   486

            if self.FilterLogMessage(message, timestamp):

   487

                return message, msgidx - 1

   488

            msgidx -= 1