1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2013: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from datetime import datetime

    27

    28

import wx

    29

    30

from graphics import DebugViewer, REFRESH_PERIOD

    31

from targets.typemapping import LogLevelsCount, LogLevels

    32

from util.BitmapLibrary import GetBitmap

    33

    35

    36

class MyScrollBar(wx.Panel):

    37

    38

    def __init__(self, parent, size):

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

    48

    49

    def GetRangeRect(self):

    50

        width, height = self.GetClientSize()

    51

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

    52

    53

    def GetThumbRect(self):

    54

        width, height = self.GetClientSize()

    55

        range_rect = self.GetRangeRect()

    66

        if self.Parent.IsMessagePanelTop():

    68

        if self.Parent.IsMessagePanelBottom():

    74

    75

    def OnLeftDown(self, event):

    76

        self.CaptureMouse()

    77

        posx, posy = event.GetPosition()

    78

        width, height = self.GetClientSize()

    79

        range_rect = self.GetRangeRect()

    80

        thumb_rect = self.GetThumbRect()

    81

        if range_rect.InsideXY(posx, posy):

    82

            if thumb_rect.InsideXY(posx, posy):

    84

            elif posy < thumb_rect.y:

    86

            elif posy > thumb_rect.y + thumb_rect.height:

    88

        elif posy < width:

    90

        elif posy > height - width:

    92

        event.Skip()

    93

    94

    def OnLeftUp(self, event):

    97

        if self.HasCapture():

    98

            self.ReleaseMouse()

    99

        event.Skip()

   100

   101

    def OnMotion(self, event):

   103

            posx, posy = event.GetPosition()

   104

            width, height = self.GetClientSize()

   105

            range_rect = self.GetRangeRect()

   110

        event.Skip()

   111

   112

    def OnResize(self, event):

   113

        self.Refresh()

   114

        event.Skip()

   115

   116

    def OnPaint(self, event):

   117

        dc = wx.BufferedPaintDC(self)

   118

        dc.Clear()

   119

        dc.BeginDrawing()

   120

   138

        dc.SetPen(wx.GREY_PEN)

   139

        dc.SetBrush(wx.GREY_BRUSH)

   140

   141

        dc.DrawPolygon([wx.Point(width / 2, 1),

   142

                        wx.Point(1, width - 2),

   143

                        wx.Point(width - 1, width - 2)])

   144

   145

        dc.DrawPolygon([wx.Point(width / 2, height - 1),

   146

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

   147

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

   149

        dc.DrawRectangle(thumb_rect.x, thumb_rect.y, 

   150

                         thumb_rect.width, thumb_rect.height)

   151

   152

        dc.EndDrawing()

   153

        event.Skip()

   154

   155

DATE_INFO_SIZE = 10

   156

MESSAGE_INFO_SIZE = 30

   157

   158

class LogMessage:

   159

   160

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

   161

        self.Date = datetime.fromtimestamp(tv_sec)

   162

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

   163

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

   164

        self.Level = level

   165

        self.LevelBitmap = level_bitmap

   166

        self.Message = msg

   167

        self.DrawDate = True

   168

   169

    def __cmp__(self, other):

   170

        if self.Date == other.Date:

   171

            return cmp(self.Seconds, other.Seconds)

   172

        return cmp(self.Date, other.Date)

   173

   174

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

   175

        if draw_date:

   176

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

   177

            dw, dh = dc.GetTextExtent(datetime_text)

   178

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

   179

            offset += DATE_INFO_SIZE

   180

   181

        seconds_text = "%12.9f" % self.Seconds

   182

        sw, sh = dc.GetTextExtent(seconds_text)

   183

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

   184

   185

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

   186

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

   187

   188

        mw, mh = dc.GetTextExtent(self.Message)

   189

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

   190

   191

    def GetHeight(self, draw_date):

   192

        if draw_date:

   193

            return DATE_INFO_SIZE + MESSAGE_INFO_SIZE

   194

        return MESSAGE_INFO_SIZE

   195

   196

SECOND = 1

   197

MINUTE = 60 * SECOND

   198

HOUR = 60 * MINUTE

   199

DAY = 24 * HOUR

   200

   201

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

   202

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

   203

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

   204

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

   205

REVERSE_CHANGE_TIMESTAMP_BUTTONS = CHANGE_TIMESTAMP_BUTTONS[:]

   206

REVERSE_CHANGE_TIMESTAMP_BUTTONS.reverse()

   207

   208

class LogViewer(DebugViewer, wx.Panel):

   209

   210

    def __init__(self, parent, window):

   211

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

   212

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

   213

   214

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

   215

        main_sizer.AddGrowableCol(0)

   216

        main_sizer.AddGrowableRow(1)

   217

   218

        filter_sizer = wx.BoxSizer(wx.HORIZONTAL)

   219

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

   220

   221

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

   222

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

   223

        levels = LogLevels[:3]

   224

        levels.reverse()

   225

        for level in levels:

   226

            self.MessageFilter.Append(_(level))

   227

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

   228

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

   229

   231

        self.SearchMessage.ShowSearchButton(True)

   234

        self.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN, 

   238

        filter_sizer.AddWindow(self.SearchMessage, 3, flag=wx.GROW)

   239

   240

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

   241

        message_panel_sizer.AddGrowableCol(1)

   242

        message_panel_sizer.AddGrowableRow(0)

   243

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

   244

   245

        buttons_sizer = wx.BoxSizer(wx.VERTICAL)

   247

                                for text, duration in CHANGE_TIMESTAMP_BUTTONS] +\

   248

                               [("-" + text, self.GenerateOnDurationButton(-duration)) 

   250

            button = wx.Button(self, label=label)

   251

            self.Bind(wx.EVT_BUTTON, callback, button)

   252

            buttons_sizer.AddWindow(button, 1, wx.ALIGN_CENTER_VERTICAL)

   253

        message_panel_sizer.AddSizer(buttons_sizer, flag=wx.GROW)

   254

   255

        self.MessagePanel = wx.Panel(self)

   256

        if wx.Platform == '__WXMSW__':

   257

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

   258

        else:

   259

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

   261

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

   262

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

   263

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

   264

   265

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

   266

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

   267

   268

        self.SetSizer(main_sizer)

   269

   270

        self.MessageFilter.SetSelection(0)

   271

        self.LogSource = None

   272

        self.ResetLogMessages()

   273

        self.ParentWindow = window

   274

   275

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

   276

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

   277

        self.CurrentFilter = self.LevelFilters[0]

   282

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

   283

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

   284

   285

    def __del__(self):

   286

        self.ScrollTimer.Stop()

   287

   288

    def ResetLogMessages(self):

   289

        self.previous_log_count = [None]*LogLevelsCount

   290

        self.OldestMessages = []

   291

        self.LogMessages = []

   292

        self.CurrentMessage = None

   293

        self.HasNewData = False

   294

   295

    def SetLogSource(self, log_source):

   296

        self.LogSource = log_source

   297

        if log_source is not None:

   298

            self.ResetLogMessages()

   299

            self.RefreshView()

   300

   301

    def GetLogMessageFromSource(self, msgidx, level):

   302

        if self.LogSource is not None:

   303

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

   304

            if answer is not None:

   305

                msg, tick, tv_sec, tv_nsec = answer

   306

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

   307

        return None

   308

   309

    def SetLogCounters(self, log_count):

   310

        new_messages = []

   311

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

   312

            if count is not None and prev != count:

   313

                if prev is None:

   314

                    dump_end = count - 2

   315

                else:

   316

                    dump_end = prev - 1

   317

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

   318

                    new_message = self.GetLogMessageFromSource(msgidx, level)

   319

                    if new_message is not None:

   320

                        if prev is None:

   321

                            self.OldestMessages.append((msgidx, new_message))

   322

                            if len(new_messages) == 0 or new_message > new_messages[0]:

   323

                                new_messages = [new_message]

   324

                        else:

   325

                            new_messages.insert(0, new_message)

   326

                    else:

   327

                        if prev is None:

   328

                            self.OldestMessages.append((-1, None))

   329

                        break

   330

                self.previous_log_count[level] = count

   331

        new_messages.sort()

   332

        if len(new_messages) > 0:

   333

            self.HasNewData = True

   334

            old_length = len(self.LogMessages)

   335

            for new_message in new_messages:

   336

                self.LogMessages.append(new_message)

   337

            if self.CurrentMessage is None or self.CurrentMessage == old_length - 1:

   338

                self.CurrentMessage = len(self.LogMessages) - 1

   339

            self.NewDataAvailable(None)

   340

   345

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

   346

            message = self.LogMessages[msgidx + 1]

   348

                return message, msgidx + 1

   349

            msgidx += 1

   350

        return None, None

   353

        message = None

   354

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

   355

            message = self.LogMessages[msgidx - 1]

   357

                return message, msgidx - 1

   358

            msgidx -= 1

   359

        if len(self.LogMessages) > 0:

   360

            message = self.LogMessages[0]

   361

            while message is not None:

   362

                level = message.Level

   363

                oldest_msgidx, oldest_message = self.OldestMessages[level]

   364

                if oldest_msgidx > 0:

   365

                    old_message = self.GetLogMessageFromSource(oldest_msgidx - 1, level)

   366

                    if old_message is not None:

   367

                        self.OldestMessages[level] = (oldest_msgidx - 1, old_message)

   368

                    else:

   369

                        self.OldestMessages[level] = (-1, None)

   370

                else:

   371

                    self.OldestMessages[level] = (-1, None)

   372

                message = None

   373

                for idx, msg in self.OldestMessages:

   374

                    if msg is not None and (message is None or msg > message):

   375

                        message = msg

   376

                if message is not None:

   377

                    self.LogMessages.insert(0, message)

   378

                    if self.CurrentMessage is not None:

   379

                        self.CurrentMessage += 1

   380

                    else:

   381

                        self.CurrentMessage = 0

   383

                        return message, 0

   384

        return None, None

   385

   386

    def RefreshNewData(self, *args, **kwargs):

   387

        if self.HasNewData:

   388

            self.HasNewData = False

   389

            self.RefreshView()

   390

        DebugViewer.RefreshNewData(self, *args, **kwargs)

   391

   392

    def RefreshView(self):

   393

        width, height = self.MessagePanel.GetClientSize()

   394

        bitmap = wx.EmptyBitmap(width, height)

   395

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

   396

        dc.Clear()

   397

        dc.SetFont(self.Font)

   398

        dc.BeginDrawing()

   399

   400

        if self.CurrentMessage is not None:

   401

            message_idx = self.CurrentMessage

   402

            message = self.LogMessages[message_idx]

   403

            draw_date = True

   404

            offset = 5

   405

            while offset < height and message is not None:

   406

                message.Draw(dc, offset, width, draw_date)

   407

                offset += message.GetHeight(draw_date)

   408

   410

                if previous_message is not None:

   411

                    draw_date = message.Date != previous_message.Date

   412

                message = previous_message

   413

   414

        dc.EndDrawing()

   415

   417

   418

    def IsMessagePanelTop(self, message_idx=None):

   419

        if message_idx is None:

   420

            message_idx = self.CurrentMessage

   421

        if message_idx is not None:

   423

        return True

   424

   425

    def IsMessagePanelBottom(self, message_idx=None):

   426

        if message_idx is None:

   427

            message_idx = self.CurrentMessage

   428

        if message_idx is not None:

   429

            width, height = self.MessagePanel.GetClientSize()

   430

            offset = 5

   431

            message = self.LogMessages[message_idx]

   432

            draw_date = True

   433

            while message is not None and offset < height:

   434

                offset += message.GetHeight(draw_date)

   436

                if previous_message is not None:

   437

                    draw_date = message.Date != previous_message.Date

   438

                message = previous_message

   439

            return offset < height

   440

        return True

   441

   442

    def ScrollMessagePanel(self, scroll):

   443

        if self.CurrentMessage is not None:

   444

            message = self.LogMessages[self.CurrentMessage]

   445

            while scroll > 0 and message is not None:

   447

                if message is not None:

   448

                    self.CurrentMessage = msgidx

   449

                    scroll -= 1

   450

            while scroll < 0 and message is not None and not self.IsMessagePanelBottom():

   452

                if message is not None:

   453

                    self.CurrentMessage = msgidx

   454

                    scroll += 1

   455

            self.RefreshView()

   458

        if len(self.LogMessages) > 0:

   459

            self.CurrentMessage = len(self.LogMessages) - 1

   460

            message = self.LogMessages[self.CurrentMessage]