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

    26

    27

import wx

    28

    29

from graphics import DebugViewer, REFRESH_PERIOD

    30

from targets.typemapping import LogLevelsCount, LogLevels

    31

from util.BitmapLibrary import GetBitmap

    32

    33

SPEED_VALUES = [10, 5, 2, 1, 0, -1, -2, -5, -10]

    34

    35

class MyScrollBar(wx.Panel):

    36

    37

    def __init__(self, parent, size):

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

    45

        self.ThumbPosition = SPEED_VALUES.index(0)

    46

        self.ThumbScrolling = False

    47

    48

    def GetRangeRect(self):

    49

        width, height = self.GetClientSize()

    50

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

    51

    52

    def GetThumbRect(self):

    53

        width, height = self.GetClientSize()

    54

        range_rect = self.GetRangeRect()

    55

        if self.Parent.IsMessagePanelTop():

    56

            thumb_start = 0

    57

        else:

    58

            thumb_start = int(float(self.ThumbPosition * range_rect.height) / len(SPEED_VALUES))

    59

        if self.Parent.IsMessagePanelBottom():

    60

            thumb_end = range_rect.height

    61

        else:

    62

            thumb_end = int(float((self.ThumbPosition + 1) * range_rect.height) / len(SPEED_VALUES))

    63

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

    64

    65

    def OnLeftDown(self, event):

    66

        self.CaptureMouse()

    67

        posx, posy = event.GetPosition()

    68

        width, height = self.GetClientSize()

    69

        range_rect = self.GetRangeRect()

    70

        thumb_rect = self.GetThumbRect()

    71

        if range_rect.InsideXY(posx, posy):

    72

            if thumb_rect.InsideXY(posx, posy):

    73

                self.ThumbScrolling = True

    74

            elif posy < thumb_rect.y:

    75

                self.Parent.ScrollPageUp()

    76

            elif posy > thumb_rect.y + thumb_rect.height:

    77

                self.Parent.ScrollPageDown()

    78

        elif posy < width:

    79

            self.Parent.SetScrollSpeed(1)

    80

        elif posy > height - width:

    81

            self.Parent.SetScrollSpeed(-1)

    82

        event.Skip()

    83

    84

    def OnLeftUp(self, event):

    85

        self.ThumbScrolling = False

    86

        self.ThumbPosition = SPEED_VALUES.index(0)

    87

        self.Parent.SetScrollSpeed(SPEED_VALUES[self.ThumbPosition])

    88

        self.Refresh()

    89

        if self.HasCapture():

    90

            self.ReleaseMouse()

    91

        event.Skip()

    92

    93

    def OnMotion(self, event):

    94

        if event.Dragging() and self.ThumbScrolling:

    95

            posx, posy = event.GetPosition()

    96

            width, height = self.GetClientSize()

    97

            range_rect = self.GetRangeRect()

    98

            if range_rect.InsideXY(posx, posy):

    99

                new_thumb_position = int(float(posy - range_rect.y) * len(SPEED_VALUES) / range_rect.height)

   100

                thumb_rect = self.GetThumbRect()

   101

                if self.ThumbPosition == SPEED_VALUES.index(0):

   102

                    if thumb_rect.y == width:

   103

                        new_thumb_position = max(new_thumb_position, SPEED_VALUES.index(0))

   104

                    if thumb_rect.y + thumb_rect.height == height - width:

   105

                        new_thumb_position = min(new_thumb_position, SPEED_VALUES.index(0))

   106

                if new_thumb_position != self.ThumbPosition:

   107

                    self.ThumbPosition = new_thumb_position

   108

                    self.Parent.SetScrollSpeed(SPEED_VALUES[new_thumb_position])

   109

                    self.Refresh()

   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

   121

        dc.SetPen(wx.GREY_PEN)

   122

        dc.SetBrush(wx.GREY_BRUSH)

   123

   124

        width, height = self.GetClientSize()

   125

   126

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

   127

                        wx.Point(1, width - 2),

   128

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

   129

   130

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

   131

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

   132

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

   133

   134

        thumb_rect = self.GetThumbRect()

   135

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

   136

                         thumb_rect.width, thumb_rect.height)

   137

   138

        dc.EndDrawing()

   139

        event.Skip()

   140

   141

DATE_INFO_SIZE = 10

   142

MESSAGE_INFO_SIZE = 30

   143

   144

class LogMessage:

   145

   146

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

   147

        self.Date = datetime.fromtimestamp(tv_sec)

   148

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

   149

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

   150

        self.Level = level

   151

        self.LevelBitmap = level_bitmap

   152

        self.Message = msg

   153

        self.DrawDate = True

   154

   155

    def __cmp__(self, other):

   156

        if self.Date == other.Date:

   157

            return cmp(self.Seconds, other.Seconds)

   158

        return cmp(self.Date, other.Date)

   159

   160

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

   161

        if draw_date:

   162

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

   163

            dw, dh = dc.GetTextExtent(datetime_text)

   164

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

   165

            offset += DATE_INFO_SIZE

   166

   167

        seconds_text = "%12.9f" % self.Seconds

   168

        sw, sh = dc.GetTextExtent(seconds_text)

   169

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

   170

   171

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

   172

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

   173

   174

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

   175

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

   176

   177

    def GetHeight(self, draw_date):

   178

        if draw_date:

   179

            return DATE_INFO_SIZE + MESSAGE_INFO_SIZE

   180

        return MESSAGE_INFO_SIZE

   181

   182

SECOND = 1

   183

MINUTE = 60 * SECOND

   184

HOUR = 60 * MINUTE

   185

DAY = 24 * HOUR

   186

   187

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

   188

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

   189

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

   190

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

   191

REVERSE_CHANGE_TIMESTAMP_BUTTONS = CHANGE_TIMESTAMP_BUTTONS[:]

   192

REVERSE_CHANGE_TIMESTAMP_BUTTONS.reverse()

   193

   194

class LogViewer(DebugViewer, wx.Panel):

   195

   196

    def __init__(self, parent, window):

   197

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

   198

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

   199

   200

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

   201

        main_sizer.AddGrowableCol(0)

   202

        main_sizer.AddGrowableRow(1)

   203

   204

        filter_sizer = wx.BoxSizer(wx.HORIZONTAL)

   205

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

   206

   207

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

   208

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

   209

        levels = LogLevels[:3]

   210

        levels.reverse()

   211

        for level in levels:

   212

            self.MessageFilter.Append(_(level))

   213

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

   214

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

   215

   216

        self.SearchMessage = wx.SearchCtrl(self)

   217

        self.SearchMessage.ShowSearchButton(True)

   218

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

   219

        self.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN, 

   220

              self.OnSearchMessageButtonClick, self.SearchMessage)

   221

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

   222

   223

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

   224

        message_panel_sizer.AddGrowableCol(1)

   225

        message_panel_sizer.AddGrowableRow(0)

   226

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

   227

   228

        buttons_sizer = wx.BoxSizer(wx.VERTICAL)

   229

        for label, callback in [(_("First"), self.OnFirstButton)] + \

   230

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

   231

                                for text, duration in CHANGE_TIMESTAMP_BUTTONS] +\

   232

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

   233

                                for text, duration in REVERSE_CHANGE_TIMESTAMP_BUTTONS] + \

   234

                               [(_("Last"), self.OnLastButton)]:

   235

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

   236

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

   237

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

   238

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

   239

   240

        self.MessagePanel = wx.Panel(self)

   241

        if wx.Platform == '__WXMSW__':

   242

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

   243

        else:

   244

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

   245

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

   246

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

   247

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

   248

   249

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

   250

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

   251

   252

        self.SetSizer(main_sizer)

   253

   254

        self.MessageFilter.SetSelection(0)

   255

        self.LogSource = None

   256

        self.ResetLogMessages()

   257

        self.ParentWindow = window

   258

   259

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

   260

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

   261

        self.CurrentFilter = self.LevelFilters[0]

   262

   263

        self.ScrollSpeed = 0

   264

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

   265

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

   266

   267

    def __del__(self):

   268

        self.ScrollTimer.Stop()

   269

   270

    def ResetLogMessages(self):

   271

        self.previous_log_count = [None]*LogLevelsCount

   272

        self.OldestMessages = []

   273

        self.LogMessages = []

   274

        self.CurrentMessage = None

   275

        self.HasNewData = False

   276

   277

    def SetLogSource(self, log_source):

   278

        self.LogSource = log_source

   279

        if log_source is not None:

   280

            self.ResetLogMessages()

   281

            self.RefreshView()

   282

   283

    def GetLogMessageFromSource(self, msgidx, level):

   284

        if self.LogSource is not None:

   285

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

   286

            if answer is not None:

   287

                msg, tick, tv_sec, tv_nsec = answer

   288

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

   289

        return None

   290

   291

    def SetLogCounters(self, log_count):

   292

        new_messages = []

   293

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

   294

            if count is not None and prev != count:

   295

                if prev is None:

   296

                    dump_end = count - 2

   297

                else:

   298

                    dump_end = prev - 1

   299

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

   300

                    new_message = self.GetLogMessageFromSource(msgidx, level)

   301

                    if new_message is not None:

   302

                        if prev is None:

   303

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

   304

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

   305

                                new_messages = [new_message]

   306

                        else:

   307

                            new_messages.insert(0, new_message)

   308

                    else:

   309

                        if prev is None:

   310

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

   311

                        break

   312

                self.previous_log_count[level] = count

   313

        new_messages.sort()

   314

        if len(new_messages) > 0:

   315

            self.HasNewData = True

   316

            old_length = len(self.LogMessages)

   317

            for new_message in new_messages:

   318

                self.LogMessages.append(new_message)

   319

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

   320

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

   321

            self.NewDataAvailable(None)

   322

   323

    def GetNextMessage(self, msgidx, levels=range(4)):

   324

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

   325

            message = self.LogMessages[msgidx + 1]

   326

            if message.Level in levels:

   327

                return message, msgidx + 1

   328

            msgidx += 1

   329

        return None, None

   330

   331

    def GetPreviousMessage(self, msgidx, levels=range(4)):

   332

        message = None

   333

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

   334

            message = self.LogMessages[msgidx - 1]

   335

            if message.Level in levels:

   336

                return message, msgidx - 1

   337

            msgidx -= 1

   338

        if len(self.LogMessages) > 0:

   339

            message = self.LogMessages[0]

   340

            while message is not None:

   341

                level = message.Level

   342

                oldest_msgidx, oldest_message = self.OldestMessages[level]

   343

                if oldest_msgidx > 0:

   344

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

   345

                    if old_message is not None:

   346

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

   347

                    else:

   348

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

   349

                else:

   350

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

   351

                message = None

   352

                for idx, msg in self.OldestMessages:

   353

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

   354

                        message = msg

   355

                if message is not None:

   356

                    self.LogMessages.insert(0, message)

   357

                    if self.CurrentMessage is not None:

   358

                        self.CurrentMessage += 1

   359

                    else:

   360

                        self.CurrentMessage = 0

   361

                    if message.Level in levels:

   362

                        return message, 0

   363

        return None, None

   364

   365

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

   366

        if self.HasNewData:

   367

            self.HasNewData = False

   368

            self.RefreshView()

   369

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

   370

   371

    def RefreshView(self):

   372

        width, height = self.MessagePanel.GetClientSize()

   373

        bitmap = wx.EmptyBitmap(width, height)

   374

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

   375

        dc.Clear()

   376

        dc.SetFont(self.Font)

   377

        dc.BeginDrawing()

   378

   379

        if self.CurrentMessage is not None:

   380

            message_idx = self.CurrentMessage

   381

            message = self.LogMessages[message_idx]

   382

            draw_date = True

   383

            offset = 5

   384

            while offset < height and message is not None:

   385

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

   386

                offset += message.GetHeight(draw_date)

   387

   388

                previous_message, message_idx = self.GetPreviousMessage(message_idx, self.CurrentFilter)

   389

                if previous_message is not None:

   390

                    draw_date = message.Date != previous_message.Date

   391

                message = previous_message

   392

   393

        dc.EndDrawing()

   394

   395

        self.MessageScrollBar.Refresh()

   396

   397

    def OnMessageFilterChanged(self, event):

   398

        self.CurrentFilter = self.LevelFilters[self.MessageFilter.GetSelection()]

   399

        if len(self.LogMessages) > 0:

   400

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

   401

            message = self.LogMessages[self.CurrentMessage]

   402

            while message is not None and message.Level not in self.CurrentFilter:

   403

                message, self.CurrentMessage = self.GetPreviousMessage(self.CurrentMessage, self.CurrentFilter)

   404

            self.RefreshView()

   405

        event.Skip()

   406

   407

    def IsMessagePanelTop(self, message_idx=None):

   408

        if message_idx is None:

   409

            message_idx = self.CurrentMessage

   410

        if message_idx is not None:

   411

            return self.GetNextMessage(message_idx, self.CurrentFilter)[0] is None

   412

        return True

   413

   414

    def IsMessagePanelBottom(self, message_idx=None):

   415

        if message_idx is None:

   416

            message_idx = self.CurrentMessage

   417

        if message_idx is not None:

   418

            width, height = self.MessagePanel.GetClientSize()

   419

            offset = 5

   420

            message = self.LogMessages[message_idx]

   421

            draw_date = True

   422

            while message is not None and offset < height:

   423

                offset += message.GetHeight(draw_date)

   424

                previous_message, message_idx = self.GetPreviousMessage(message_idx, self.CurrentFilter)

   425

                if previous_message is not None:

   426

                    draw_date = message.Date != previous_message.Date

   427

                message = previous_message

   428

            return offset < height

   429

        return True

   430

   431

    def ScrollMessagePanel(self, scroll):

   432

        if self.CurrentMessage is not None:

   433

            message = self.LogMessages[self.CurrentMessage]

   434

            while scroll > 0 and message is not None:

   435

                message, msgidx = self.GetNextMessage(self.CurrentMessage, self.CurrentFilter)

   436

                if message is not None:

   437

                    self.CurrentMessage = msgidx

   438

                    scroll -= 1

   439

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

   440

                message, msgidx = self.GetPreviousMessage(self.CurrentMessage, self.CurrentFilter)

   441

                if message is not None:

   442

                    self.CurrentMessage = msgidx

   443

                    scroll += 1

   444

            self.RefreshView()

   445

   446

    def OnSearchMessageChanged(self, event):

   447

        event.Skip()

   448

   449

    def OnSearchMessageButtonClick(self, event):

   450

        event.Skip()

   451

   452

    def OnFirstButton(self, event):

   453

        if len(self.LogMessages) > 0:

   454

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

   455

            message = self.LogMessages[self.CurrentMessage]

   456

            if message.Level not in self.CurrentFilter:

   457

                message, self.CurrentMessage = self.GetPreviousMessage(self.CurrentMessage, self.CurrentFilter)

   458

            self.RefreshView()

   459

        event.Skip()

   460

   461

    def OnLastButton(self, event):

   462

        if len(self.LogMessages) > 0:

   463

            message_idx = 0

   464

            message = self.LogMessages[message_idx]

   465

            if message.Level not in self.CurrentFilter:

   466

                next_message, msgidx = self.GetNextMessage(message_idx, self.CurrentFilter)

   467

                if next_message is not None:

   468

                    message_idx = msgidx

   469

                    message = next_message

   470

            while message is not None:

   471

                message, msgidx = self.GetPreviousMessage(message_idx, self.CurrentFilter)

   472

                if message is not None:

   473

                    message_idx = msgidx

   474

            message = self.LogMessages[message_idx]

   475

            if message.Level in self.CurrentFilter:

   476

                while message is not None:

   477

                    message, msgidx = self.GetNextMessage(message_idx, self.CurrentFilter)

   478

                    if message is not None:

   479

                        if not self.IsMessagePanelBottom(msgidx):

   480

                            break

   481

                        message_idx = msgidx

   482

                self.CurrentMessage = message_idx

   483

            else:

   484

                self.CurrentMessage = None

   485

            self.RefreshView()

   486

        event.Skip()

   487

   488

    def GenerateOnDurationButton(self, duration):

   489

        def OnDurationButton(event):

   490

            event.Skip()

   491

        return OnDurationButton

   492

   493

    def OnMessagePanelPaint(self, event):

   494

        self.RefreshView()

   495

        event.Skip()

   496

   497

    def OnMessagePanelResize(self, event):

   498

        self.RefreshView()

   499

        event.Skip()

   500

   501

    def OnScrollTimer(self, event):

   502

        if self.ScrollSpeed != 0:

   503

            speed_norm = abs(self.ScrollSpeed)

   504

            if speed_norm <= 5:

   505

                self.ScrollMessagePanel(speed_norm / self.ScrollSpeed)

   506

                period = REFRESH_PERIOD * 5000 / speed_norm

   507

            else:

   508

                self.ScrollMessagePanel(self.ScrollSpeed / 5)

   509

                period = REFRESH_PERIOD * 1000

   510

            self.ScrollTimer.Start(period, True)

   511

        event.Skip()

   512

   513

    def SetScrollSpeed(self, speed):

   514

        if speed == 0:

   515

            self.ScrollTimer.Stop()

   516

        else:

   517

            if not self.ScrollTimer.IsRunning():

   518

                speed_norm = abs(speed)

   519

                if speed_norm <= 5:

   520

                    self.ScrollMessagePanel(speed_norm / speed)

   521

                    period = REFRESH_PERIOD * 5000 / speed_norm

   522

                else:

   523

                    period = REFRESH_PERIOD * 1000

   524

                    self.ScrollMessagePanel(speed / 5)

   525

                self.ScrollTimer.Start(period, True)

   526

        self.ScrollSpeed = speed    

   527

   528

    def ScrollPageUp(self):

   529

        pass

   530