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.InsideXY(posx, posy):

   103

            if thumb_rect.InsideXY(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

        dc.BeginDrawing()

   143

   144

        gc = wx.GCDC(dc)

   145

   146

        width, height = self.GetClientSize()

   147

   148

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

   149

        gc.SetBrush(wx.GREY_BRUSH)

   150

   151

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

   152

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

   153

   154

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

   155

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

   156

   157

        thumb_rect = self.GetThumbRect()

   158

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

   159

                                 thumb_rect.width, thumb_rect.height)

   160

        if self.Parent.IsMessagePanelTop():

   161

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

   162

        if self.Parent.IsMessagePanelBottom():

   163

            exclusion_rect.height = height - width - exclusion_rect.y

   164

        if exclusion_rect != thumb_rect:

   165

            colour = wx.NamedColour("LIGHT GREY")

   166

            gc.SetPen(wx.Pen(colour))

   167

            gc.SetBrush(wx.Brush(colour))

   168

   169

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

   170

                             exclusion_rect.width, exclusion_rect.height)

   171

   172

        gc.SetPen(wx.GREY_PEN)

   173

        gc.SetBrush(wx.GREY_BRUSH)

   174

   175

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

   176

   177

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

   178

   179

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

   180

                         thumb_rect.width, thumb_rect.height)

   181

   182

        dc.EndDrawing()

   183

        event.Skip()

   184

   185

   186

BUTTON_SIZE = (70, 15)

   187

   188

   189

class LogButton(object):

   190

   191

    def __init__(self, label, callback):

   192

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

   193

        self.Size = wx.Size(*BUTTON_SIZE)

   194

        self.Label = label

   195

        self.Shown = True

   196

        self.Callback = callback

   197

   198

    def __del__(self):

   199

        self.callback = None

   200

   201

    def GetSize(self):

   202

        return self.Size

   203

   204

    def SetPosition(self, x, y):

   205

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

   206

   207

    def HitTest(self, x, y):

   208

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

   209

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

   210

        if rect.InsideXY(x, y):

   211

            return True

   212

        return False

   213

   214

    def ProcessCallback(self):

   215

        if self.Callback is not None:

   216

            wx.CallAfter(self.Callback)

   217

   218

    def Draw(self, dc):

   219

        dc.SetPen(wx.TRANSPARENT_PEN)

   220

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

   221

   222

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

   223

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

   224

   225

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

   226

        dc.DrawText(self.Label,

   227

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

   228

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

   229

   230

   231

DATE_INFO_SIZE = 10

   232

MESSAGE_INFO_SIZE = 18

   233

   234

   235

class LogMessage(object):

   236

   237

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

   238

        self.Date = datetime.utcfromtimestamp(tv_sec)

   239

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

   240

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

   241

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

   242

        self.Level = level

   243

        self.LevelBitmap = level_bitmap

   244

        self.Message = msg

   245

        self.DrawDate = True

   246

   247

    def __cmp__(self, other):

   248

        if self.Date == other.Date:

   249

            return cmp(self.Seconds, other.Seconds)

   250

        return cmp(self.Date, other.Date)

   251

   252

    def GetFullText(self):

   253

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

   254

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

   255

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

   256

            LogLevels[self.Level],

   257

            str(date), nsec,

   258

            self.Message)

   259

   260

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

   261

        if draw_date:

   262

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

   263

            dw, dh = dc.GetTextExtent(datetime_text)

   264

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

   265

            offset += DATE_INFO_SIZE

   266

   267

        seconds_text = "%12.9f" % self.Seconds

   268

        sw, sh = dc.GetTextExtent(seconds_text)

   269

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

   270

   271

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

   272

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

   273

   274

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

   275

        _mw, mh = dc.GetTextExtent(text)

   276

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

   277

   278

    def GetHeight(self, draw_date):

   279

        if draw_date:

   280

            return DATE_INFO_SIZE + MESSAGE_INFO_SIZE

   281

        return MESSAGE_INFO_SIZE

   282

   283

   284

SECOND = 1

   285

MINUTE = 60 * SECOND

   286

HOUR = 60 * MINUTE

   287

DAY = 24 * HOUR

   288

   289

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

   290

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

   291

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

   292

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

   293

   294

   295

class LogViewer(DebugViewer, wx.Panel):

   296

   297

    def __init__(self, parent, window):

   298

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

   299

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

   300

   301

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

   302

        main_sizer.AddGrowableCol(0)

   303

        main_sizer.AddGrowableRow(1)

   304

   305

        filter_sizer = wx.BoxSizer(wx.HORIZONTAL)

   306

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

   307

   308

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

   309

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

   310

        levels = LogLevels[:3]

   311

        levels.reverse()

   312

        for level in levels:

   313

            self.MessageFilter.Append(_(level))

   314

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

   315

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

   316

   317

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

   318

        self.SearchMessage.ShowSearchButton(True)

   319

        self.SearchMessage.ShowCancelButton(True)

   320

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

   321

        self.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN,

   322

                  self.OnSearchMessageSearchButtonClick, self.SearchMessage)

   323

        self.Bind(wx.EVT_SEARCHCTRL_CANCEL_BTN,

   324

                  self.OnSearchMessageCancelButtonClick, self.SearchMessage)

   325

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

   326

   327

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

   328

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

   329

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

   330

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

   331

        filter_sizer.AddWindow(self.CleanButton)

   332

   333

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

   334

        message_panel_sizer.AddGrowableCol(0)

   335

        message_panel_sizer.AddGrowableRow(0)

   336

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

   337

   338

        self.MessagePanel = wx.Panel(self)

   339

        if wx.Platform == '__WXMSW__':

   340

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

   341

        else:

   342

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

   343

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

   344

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

   345

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

   346

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

   347

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

   348

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

   349

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

   350

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

   351

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

   352

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

   353

   354

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

   355

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

   356

   357

        self.SetSizer(main_sizer)

   358

   359

        self.LeftButtons = []

   360

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

   361

                                for text, duration in CHANGE_TIMESTAMP_BUTTONS]:

   362

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

   363

   364

        self.RightButtons = []

   365

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

   366

                                for text, duration in CHANGE_TIMESTAMP_BUTTONS]:

   367

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

   368

   369

        self.MessageFilter.SetSelection(0)

   370

        self.LogSource = None

   371

        self.ResetLogMessages()

   372

        self.ParentWindow = window

   373

   374

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

   375

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

   376

        self.CurrentFilter = self.LevelFilters[0]

   377

        self.CurrentSearchValue = ""

   378

   379

        self.ScrollSpeed = 0.

   380

        self.LastStartTime = None

   381

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

   382

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

   383

   384

        self.LastMousePos = None

   385

        self.MessageToolTip = None

   386

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

   387

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

   388

   389

    def __del__(self):

   390

        self.ScrollTimer.Stop()

   391

   392

    def ResetLogMessages(self):

   393

        self.ResetLogCounters()

   394

        self.OldestMessages = []

   395

        self.LogMessages = []

   396

        self.LogMessagesTimestamp = numpy.array([])

   397

        self.CurrentMessage = None

   398

        self.HasNewData = False

   399

   400

    def SetLogSource(self, log_source):

   401

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

   402

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

   403

        if log_source is not None:

   404

            self.ResetLogMessages()

   405

            wx.CallAfter(self.RefreshView)

   406

   407

    def GetLogMessageFromSource(self, msgidx, level):

   408

        if self.LogSource is not None:

   409

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

   410

            if answer is not None:

   411

                msg, _tick, tv_sec, tv_nsec = answer

   412

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

   413

        return None

   414

   415

    def ResetLogCounters(self):

   416

        self.previous_log_count = [None]*LogLevelsCount

   417

   418

    def SetLogCounters(self, log_count):

   419

        new_messages = []

   420

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

   421

            if count is not None and prev != count:

   422

                if prev is None:

   423

                    dump_end = max(-1, count - 10)

   424

                    oldest_message = (-1, None)

   425

                else:

   426

                    dump_end = prev - 1

   427

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

   428

                    new_message = self.GetLogMessageFromSource(msgidx, level)

   429

                    if new_message is None:

   430

                        if prev is None:

   431

                            oldest_message = (-1, None)

   432

                        break

   433

                    if prev is None:

   434

                        oldest_message = (msgidx, new_message)

   435

                        if len(new_messages) == 0:

   436

                            new_messages = [new_message]

   437

                        else:

   438

                            new_messages.insert(0, new_message)

   439

                    else:

   440

                        new_messages.insert(0, new_message)

   441

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

   442

                    self.OldestMessages.append(oldest_message)

   443

                self.previous_log_count[level] = count

   444

        new_messages.sort()

   445

        if len(new_messages) > 0:

   446

            self.HasNewData = True

   447

            if self.CurrentMessage is not None:

   448

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

   449

            else:

   450

                current_is_last = True

   451

            for new_message in new_messages:

   452

                self.LogMessages.append(new_message)

   453

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

   454

            if current_is_last:

   455

                self.ScrollToLast(False)

   456

                self.ResetMessageToolTip()

   457

                self.MessageToolTipTimer.Stop()

   458

                self.ParentWindow.SelectTab(self)

   459

            self.NewDataAvailable(None)

   460

   461

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

   462

        return (message.Level in self.CurrentFilter and

   463

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

   464

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

   465

   466

    def GetMessageByTimestamp(self, timestamp):

   467

        if self.CurrentMessage is not None:

   468

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

   469

            message = self.LogMessages[msgidx]

   470

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

   471

                return self.GetPreviousMessage(msgidx, timestamp)

   472

            return message, msgidx

   473

        return None, None

   474

   475

    def GetNextMessage(self, msgidx):

   476

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

   477

            message = self.LogMessages[msgidx + 1]

   478

            if self.FilterLogMessage(message):

   479

                return message, msgidx + 1

   480

            msgidx += 1

   481

        return None, None

   482

   483

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

   484

        message = None