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) 2007: Edouard TISSERANT and Laurent BESSARD

     8

# Copyright (C) 2016: Andrey Skvortsov <andrej.skvortzov@gmail.com>

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

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

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

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

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

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

    23

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

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

    27

from __future__ import absolute_import

    28

from __future__ import print_function

    29

import os

    30

import sys

    31

import tempfile

    32

import shutil

    33

import random

    34

import time

    35

from time import time as gettime

    36

from threading import Lock, Timer, currentThread

    37

    38

from six.moves import cPickle, xrange

    39

import wx.lib.buttons

    40

import wx.lib.statbmp

    41

import wx.stc

    42

    43

    44

import version

    45

from editors.EditorPanel import EditorPanel

    46

from editors.Viewer import Viewer

    47

from editors.TextViewer import TextViewer

    48

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    49

from editors.DataTypeEditor import DataTypeEditor

    50

from util import paths as paths

    51

from util.MiniTextControler import MiniTextControler

    52

from util.ProcessLogger import ProcessLogger

    53

from util.BitmapLibrary import GetBitmap

    54

from controls.LogViewer import LogViewer

    55

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    56

from controls import EnhancedStatusBar as esb

    57

from dialogs.AboutDialog import ShowAboutDialog

    58

    59

from plcopen.types_enums import \

    60

    ComputeConfigurationName, \

    61

    LOCATION_CONFNODE, \

    62

    LOCATION_MODULE, \

    63

    LOCATION_GROUP, \

    64

    LOCATION_VAR_INPUT, \

    65

    LOCATION_VAR_OUTPUT, \

    66

    LOCATION_VAR_MEMORY, \

    67

    ITEM_PROJECT, \

    68

    ITEM_RESOURCE, \

    69

    ITEM_CONFNODE

    70

    71

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL

    72

    73

from IDEFrame import \

    74

    TITLE,\

    75

    EDITORTOOLBAR,\

    76

    FILEMENU,\

    77

    EDITMENU,\

    78

    DISPLAYMENU,\

    79

    PROJECTTREE,\

    80

    POUINSTANCEVARIABLESPANEL,\

    81

    LIBRARYTREE,\

    82

    PAGETITLES,\

    83

    IDEFrame, \

    84

    EncodeFileSystemPath, \

    85

    DecodeFileSystemPath

    86

    87

    88

beremiz_dir = paths.AbsDir(__file__)

    89

    90

    91

def Bpath(*args):

    92

    return os.path.join(beremiz_dir, *args)

    93

    94

def AppendMenu(parent, help, id, kind, text):

    95

    return parent.Append(wx.MenuItem(helpString=help, id=id, kind=kind, text=text))

    96

    97

MAX_RECENT_PROJECTS = 9

    98

    99

   100

if wx.Platform == '__WXMSW__':

   101

    faces = {

   102

        'mono': 'Courier New',

   103

        'size': 8,

   104

    }

   105

else:

   106

    faces = {

   107

        'mono': 'FreeMono',

   108

        'size': 10,

   109

    }

   110

   111

   112

MainThread = currentThread().ident

   113

REFRESH_PERIOD = 0.1

   114

   115

   116

class LogPseudoFile(object):

   117

    """ Base class for file like objects to facilitate StdOut for the Shell."""

   119

        self.red_white = 1

   120

        self.red_yellow = 2

   121

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   122

        self.output = output

   123

        self.risecall = risecall

   124

        # to prevent rapid fire on rising log panel

   125

        self.rising_timer = 0

   126

        self.StackLock = Lock()

   127

        self.YieldLock = Lock()

   128

        self.RefreshLock = Lock()

   129

        self.TimerAccessLock = Lock()

   130

        self.stack = []

   131

        self.LastRefreshTime = gettime()

   132

        self.LastRefreshTimer = None

   133

        self.refreshPending = False

   135

   136

    def write(self, s, style=None):

   139

        self.StackLock.acquire()

   140

        self.stack.append((s, style))

   141

        self.StackLock.release()

   142

        current_time = gettime()

   143

        with self.TimerAccessLock:

   144

            if self.LastRefreshTimer is not None:

   145

                self.LastRefreshTimer.cancel()

   146

                self.LastRefreshTimer = None

   147

        elapsed = current_time - self.LastRefreshTime

   148

        if elapsed > REFRESH_PERIOD:

   149

            self._should_write()

   150

        else:

   151

            with self.TimerAccessLock:

   152

                if self.LastRefreshTimer is None:

   153

                    self.LastRefreshTimer = Timer(REFRESH_PERIOD - elapsed, self._timer_expired)

   154

                    self.LastRefreshTimer.start()

   155

   156

    def _timer_expired(self):

   157

        self._should_write()

   158

        with self.TimerAccessLock:

   159

            self.LastRefreshTimer = None

   160

   161

    def _should_write(self):

   162

        if MainThread == currentThread().ident:

   163

            app = wx.GetApp()

   164

            if app is not None:

   165

                self._write()

   166

                if self.YieldLock.acquire(0):

   167

                    app.Yield()

   168

                    self.YieldLock.release()

   169

        else:

   170

            with self.RefreshLock:

   171

                if not self.refreshPending:

   172

                    self.refreshPending = True

   173

                    wx.CallAfter(self._write)

   174

   175

    def _write(self):

   176

        if self.output:

   177

            with self.RefreshLock:

   178

                self.output.Freeze()

   179

                self.output.AnnotationClearAll()

   180

                self.StackLock.acquire()

   181

                for s, style in self.stack:

   182

                    if style is None:

   183

                        style = self.black_white

   184

                    if style != self.black_white:

   185

                        self.output.StartStyling(self.output.GetLength())

   186

   187

                    # Temporary deactivate read only mode on StyledTextCtrl for

   188

                    # adding text. It seems that text modifications, even

   189

                    # programmatically, are disabled in StyledTextCtrl when read

   190

                    # only is active

   191

                    start_pos = self.output.GetLength()

   192

                    self.output.SetReadOnly(False)

   193

                    self.output.AppendText(s)

   194

                    self.output.SetReadOnly(True)

   195

                    text_len = self.output.GetLength() - start_pos

   196

   197

                    if style != self.black_white:

   198

                        self.output.SetStyling(text_len, style)

   199

                self.stack = []

   200

                self.StackLock.release()

   201

                self.output.ScrollToEnd()

   202

                self.output.Thaw()

   203

                self.LastRefreshTime = gettime()

   204

                newtime = time.time()

   205

                if newtime - self.rising_timer > 1:

   206

                    self.risecall(self.output)

   207

                self.rising_timer = newtime

   208

                self.refreshPending = False

   209

   210

   211

    def write_warning(self, s):

   212

        self.write(s, self.red_white)

   213

   214

    def write_error(self, s):

   215

        self.write(s, self.red_yellow)

   216

   217

    def flush(self):

   218

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   219

        # text. It seems that text modifications, even programmatically, are

   220

        # disabled in StyledTextCtrl when read only is active

   221

        self.output.SetReadOnly(False)

   222

        self.output.SetText("")

   223

        self.output.SetReadOnly(True)

   224

   225

    def isatty(self):

   226

        return False

   227

   228

    def progress(self, text):

   229

        l = max(self.output.GetLineCount()-2, 0)

   230

        self.output.AnnotationSetText(l, text)

   231

        self.output.AnnotationSetVisible(wx.stc.STC_ANNOTATION_BOXED)

   232

        self.output.AnnotationSetStyle(l, self.black_white)

   233

        if self.YieldLock.acquire(0):

   234

            app = wx.GetApp()

   235

            app.Yield()

   236

            self.YieldLock.release()

   237

   238

   239

ID_FILEMENURECENTPROJECTS = wx.NewId()

   240

   241

   242

class Beremiz(IDEFrame):

   243

   244

    def _init_utils(self):

   245

        self.ConfNodeMenu = wx.Menu(title='')

   246

        self.RecentProjectsMenu = wx.Menu(title='')

   247

        self.TutorialsProjectsMenu = wx.Menu(title='')

   248

   249

        IDEFrame._init_utils(self)

   250

   251

    def _init_coll_FileMenu_Items(self, parent):

   252

        AppendMenu(parent, help='', id=wx.ID_NEW,

   253

                   kind=wx.ITEM_NORMAL, text=_(u'New') + '\tCTRL+N')

   254

        AppendMenu(parent, help='', id=wx.ID_OPEN,

   255

                   kind=wx.ITEM_NORMAL, text=_(u'Open') + '\tCTRL+O')

   256

        parent.Append(ID_FILEMENURECENTPROJECTS, _("&Recent Projects"), self.RecentProjectsMenu)

   257

        parent.AppendSeparator()

   258

        parent.Append(wx.ID_ANY, _("&Tutorials and Examples"), self.TutorialsProjectsMenu)

   259

   260

        exemples_dir = Bpath("exemples")

   261

        project_list = sorted(os.listdir(exemples_dir))

   262

   263

        for idx, dirname  in enumerate(project_list):

   264

            text = u'&%d: %s' % (idx + 1, dirname)

   265

   266

            item = self.TutorialsProjectsMenu.Append(wx.ID_ANY, text, '')

   267

   268

            projectpath = os.path.join(exemples_dir, dirname)

   269

   270

            def OpenExemple(event, projectpath=projectpath):

   271

                if self.CTR is not None and not self.CheckSaveBeforeClosing():

   272

                    return

   273

   274

                self.OpenProject(projectpath)

   275

                if not self.CTR.CheckProjectPathPerm():

   276

                    self.ResetView()

   277

   278

            self.Bind(wx.EVT_MENU, OpenExemple, item)

   279

        parent.AppendSeparator()

   280

        AppendMenu(parent, help='', id=wx.ID_SAVE,

   281

                   kind=wx.ITEM_NORMAL, text=_(u'Save') + '\tCTRL+S')

   282

        AppendMenu(parent, help='', id=wx.ID_SAVEAS,

   283

                   kind=wx.ITEM_NORMAL, text=_(u'Save as') + '\tCTRL+SHIFT+S')

   284

        AppendMenu(parent, help='', id=wx.ID_CLOSE,

   285

                   kind=wx.ITEM_NORMAL, text=_(u'Close Tab') + '\tCTRL+W')

   286

        AppendMenu(parent, help='', id=wx.ID_CLOSE_ALL,

   287

                   kind=wx.ITEM_NORMAL, text=_(u'Close Project') + '\tCTRL+SHIFT+W')

   288

        parent.AppendSeparator()

   289

        AppendMenu(parent, help='', id=wx.ID_PAGE_SETUP,

   290

                   kind=wx.ITEM_NORMAL, text=_(u'Page Setup') + '\tCTRL+ALT+P')

   291

        AppendMenu(parent, help='', id=wx.ID_PREVIEW,

   292

                   kind=wx.ITEM_NORMAL, text=_(u'Preview') + '\tCTRL+SHIFT+P')

   293

        AppendMenu(parent, help='', id=wx.ID_PRINT,

   294

                   kind=wx.ITEM_NORMAL, text=_(u'Print') + '\tCTRL+P')

   295

        parent.AppendSeparator()

   296

        AppendMenu(parent, help='', id=wx.ID_EXIT,

   297

                   kind=wx.ITEM_NORMAL, text=_(u'Quit') + '\tCTRL+Q')

   298

   299

        self.Bind(wx.EVT_MENU, self.OnNewProjectMenu, id=wx.ID_NEW)

   300

        self.Bind(wx.EVT_MENU, self.OnOpenProjectMenu, id=wx.ID_OPEN)

   301

        self.Bind(wx.EVT_MENU, self.OnSaveProjectMenu, id=wx.ID_SAVE)

   302

        self.Bind(wx.EVT_MENU, self.OnSaveProjectAsMenu, id=wx.ID_SAVEAS)

   303

        self.Bind(wx.EVT_MENU, self.OnCloseTabMenu, id=wx.ID_CLOSE)

   304

        self.Bind(wx.EVT_MENU, self.OnCloseProjectMenu, id=wx.ID_CLOSE_ALL)

   305

        self.Bind(wx.EVT_MENU, self.OnPageSetupMenu, id=wx.ID_PAGE_SETUP)

   306

        self.Bind(wx.EVT_MENU, self.OnPreviewMenu, id=wx.ID_PREVIEW)

   307

        self.Bind(wx.EVT_MENU, self.OnPrintMenu, id=wx.ID_PRINT)

   308

        self.Bind(wx.EVT_MENU, self.OnQuitMenu, id=wx.ID_EXIT)

   309

   310

        self.AddToMenuToolBar([(wx.ID_NEW, "new", _(u'New'), None),

   311

                               (wx.ID_OPEN, "open", _(u'Open'), None),

   312

                               (wx.ID_SAVE, "save", _(u'Save'), None),

   313

                               (wx.ID_SAVEAS, "saveas", _(u'Save As...'), None),

   314

                               (wx.ID_PRINT, "print", _(u'Print'), None)])

   315

   316

    def _RecursiveAddMenuItems(self, menu, items):

   317

        for name, text, helpstr, children in items:

   318

            if len(children) > 0:

   319

                new_menu = wx.Menu(title='')

   320

                menu.AppendSubMenu(new_menu, text)

   321

                self._RecursiveAddMenuItems(new_menu, children)

   322

            else:

   323

                item = menu.Append(wx.MenuItem(text=text, helpString=helpstr, kind=wx.ITEM_NORMAL, id=wx.ID_ANY))

   324

                self.Bind(wx.EVT_MENU, self.GetAddConfNodeFunction(name), item)

   325

   326

    def _init_coll_AddMenu_Items(self, parent):

   327

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   328

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   329

   330

    def _init_coll_HelpMenu_Items(self, parent):

   331

        def handler(event):

   332

            return wx.MessageBox(

   333

                version.GetCommunityHelpMsg(),

   334

                _(u'Community support'),

   335

                wx.OK | wx.ICON_INFORMATION)

   336

   337

        item = parent.Append(wx.ID_ANY, _(u'Community support'), '')

   338

        self.Bind(wx.EVT_MENU, handler, item)

   339

   340

        parent.Append(wx.MenuItem(helpString='', id=wx.ID_ABOUT,

   341

                      kind=wx.ITEM_NORMAL, text=_(u'About')))

   342

        self.Bind(wx.EVT_MENU, self.OnAboutMenu, id=wx.ID_ABOUT)

   343

   344

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   345

        parent.SetFieldsCount(3)

   346

   347

        parent.SetStatusText(i=0, text='')

   348

        parent.SetStatusText(i=1, text='')

   349

        parent.SetStatusText(i=2, text='')

   350

   351

        parent.SetStatusWidths([-1, 300, 200])

   352

   353

    def _init_ctrls(self, prnt):

   354

        IDEFrame._init_ctrls(self, prnt)

   355

   356

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   357

   358

        inspectorID = wx.NewId()

   359

        self.Bind(wx.EVT_MENU, self.OnOpenWidgetInspector, id=inspectorID)

   360

        accels = [wx.AcceleratorEntry(wx.ACCEL_CTRL | wx.ACCEL_ALT, ord('I'), inspectorID)]

   361

   362

        for method, shortcut in [("Stop",     wx.WXK_F4),

   363

                                 ("Run",      wx.WXK_F5),

   364

                                 ("Transfer", wx.WXK_F6),

   365

                                 ("Connect",  wx.WXK_F7),

   366

                                 ("Clean",    wx.WXK_F9),

   367

                                 ("Build",    wx.WXK_F11)]:

   368

            def OnMethodGen(obj, meth):

   369

                def OnMethod(evt):

   370

                    if obj.CTR is not None:

   371

                        obj.CTR.CallMethod('_'+meth)

   372

                    wx.CallAfter(self.RefreshStatusToolBar)

   373

                return OnMethod

   374

            newid = wx.NewId()

   375

            self.Bind(wx.EVT_MENU, OnMethodGen(self, method), id=newid)

   376

            accels += [wx.AcceleratorEntry(wx.ACCEL_NORMAL, shortcut, newid)]

   377

   378

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   379

   380

        self.LogConsole = CustomStyledTextCtrl(

   381

            name='LogConsole', parent=self.BottomNoteBook, pos=wx.Point(0, 0),

   382

            size=wx.Size(0, 0))

   383

        self.LogConsole.Bind(wx.EVT_SET_FOCUS, self.OnLogConsoleFocusChanged)

   384

        self.LogConsole.Bind(wx.EVT_KILL_FOCUS, self.OnLogConsoleFocusChanged)

   385

        self.LogConsole.Bind(wx.stc.EVT_STC_UPDATEUI, self.OnLogConsoleUpdateUI)

   386

        self.LogConsole.SetReadOnly(True)

   387

        self.LogConsole.SetWrapMode(wx.stc.STC_WRAP_CHAR)

   388

   389

        # Define Log Console styles

   390

        self.LogConsole.StyleSetSpec(wx.stc.STC_STYLE_DEFAULT, "face:%(mono)s,size:%(size)d" % faces)

   391

        self.LogConsole.StyleClearAll()

   392

        self.LogConsole.StyleSetSpec(1, "face:%(mono)s,fore:#FF0000,size:%(size)d" % faces)

   393

        self.LogConsole.StyleSetSpec(2, "face:%(mono)s,fore:#FF0000,back:#FFFF00,size:%(size)d" % faces)

   394

   395

        # Define Log Console markers

   396

        self.LogConsole.SetMarginSensitive(1, True)

   397

        self.LogConsole.SetMarginType(1, wx.stc.STC_MARGIN_SYMBOL)

   398

        self.LogConsole.MarkerDefine(0, wx.stc.STC_MARK_CIRCLE, "BLACK", "RED")

   399

   400

        self.LogConsole.SetModEventMask(wx.stc.STC_MOD_INSERTTEXT)

   401

   402

        self.LogConsole.Bind(wx.stc.EVT_STC_MARGINCLICK, self.OnLogConsoleMarginClick)

   403

        self.LogConsole.Bind(wx.stc.EVT_STC_MODIFIED, self.OnLogConsoleModified)

   404

   405

        self.MainTabs["LogConsole"] = (self.LogConsole, _("Console"))

   406

        self.BottomNoteBook.AddPage(*self.MainTabs["LogConsole"])

   407

        # self.BottomNoteBook.Split(self.BottomNoteBook.GetPageIndex(self.LogConsole), wx.RIGHT)

   408

   409

        self.LogViewer = LogViewer(self.BottomNoteBook, self)

   410

        self.MainTabs["LogViewer"] = (self.LogViewer, _("PLC Log"))

   411

        self.BottomNoteBook.AddPage(*self.MainTabs["LogViewer"])

   412

        # self.BottomNoteBook.Split(self.BottomNoteBook.GetPageIndex(self.LogViewer), wx.RIGHT)

   413

   414

        StatusToolBar = wx.ToolBar(self, -1, wx.DefaultPosition, wx.DefaultSize,

   415

                                   wx.TB_FLAT | wx.TB_NODIVIDER | wx.NO_BORDER)

   416

        StatusToolBar.SetToolBitmapSize(wx.Size(25, 25))

   417

        StatusToolBar.Realize()

   418

        self.Panes["StatusToolBar"] = StatusToolBar

   419

        self.AUIManager.AddPane(StatusToolBar, wx.aui.AuiPaneInfo().

   420

                                Name("StatusToolBar").Caption(_("Status ToolBar")).

   421

                                ToolbarPane().Top().Position(1).

   422

                                LeftDockable(False).RightDockable(False))

   423

   424

        self.AUIManager.Update()

   425

   426

        self.ConnectionStatusBar = esb.EnhancedStatusBar(self, style=wx.STB_SIZEGRIP)

   427

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   428

        self.ProgressStatusBar = wx.Gauge(self.ConnectionStatusBar, -1, range=100)

   429

        self.ConnectionStatusBar.AddWidget(self.ProgressStatusBar, esb.ESB_EXACT_FIT, esb.ESB_EXACT_FIT, 2)

   430

        self.ProgressStatusBar.Hide()

   431

        self.SetStatusBar(self.ConnectionStatusBar)

   432

   433

    def __init_execute_path(self):

   434

        if os.name == 'nt':

   435

            # on windows, desktop shortcut launches Beremiz.py

   436

            # with working dir set to mingw/bin.

   437

            # then we prefix CWD to PATH in order to ensure that

   438

            # commands invoked by build process by default are

   439

            # found here.

   440

            os.environ["PATH"] = os.getcwd()+';'+os.environ["PATH"]

   441

   443

        # Add beremiz's icon in top left corner of the frame

   444

        self.icon = wx.Icon(Bpath("images", "brz.ico"), wx.BITMAP_TYPE_ICO)

   445

        self.__init_execute_path()

   446

   447

        IDEFrame.__init__(self, parent, debug)

   449

   450

        self.local_runtime = None

   451

        self.runtime_port = None

   452

        self.local_runtime_tmpdir = None

   453

   454

        self.LastPanelSelected = None

   455

   456

        # Define Tree item icon list

   457

        self.LocationImageList = wx.ImageList(16, 16)

   458

        self.LocationImageDict = {}

   459

   460

        # Icons for location items

   461

        for imgname, itemtype in [

   462

                ("CONFIGURATION", LOCATION_CONFNODE),

   463

                ("RESOURCE",      LOCATION_MODULE),

   464

                ("PROGRAM",       LOCATION_GROUP),

   465

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   466

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   467

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   468

            self.LocationImageDict[itemtype] = self.LocationImageList.Add(GetBitmap(imgname))

   469

   470

        # Icons for other items

   471

        for imgname, itemtype in [

   472

                ("Extension", ITEM_CONFNODE)]:

   473

            self.TreeImageDict[itemtype] = self.TreeImageList.Add(GetBitmap(imgname))

   474

   475

        if projectOpen is not None:

   476

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   477

   478

        if projectOpen is not None and os.path.isdir(projectOpen):

   479

            self.CTR = ProjectController(self, self.Log)

   480

            self.Controler = self.CTR

   481

            result, _err = self.CTR.LoadProject(projectOpen, buildpath)

   482

            if not result:

   483

                self.LibraryPanel.SetController(self.Controler)

   484

                self.ProjectTree.Enable(True)

   485

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   486

                self.RefreshConfigRecentProjects(os.path.abspath(projectOpen))

   487

                self.RefreshAfterLoad()

   488

            else:

   489

                self.ResetView()

   490

                self.ShowErrorMessage(result)

   491

        else:

   492

            self.CTR = ctr

   493

            self.Controler = ctr

   494

            if ctr is not None:

   495

                ctr.SetAppFrame(self, self.Log)

   496

                self.LibraryPanel.SetController(self.Controler)

   497

                self.ProjectTree.Enable(True)

   498

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   499

                self.RefreshAfterLoad()

   500

        if self.EnableDebug:

   501

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   502

   503

        self._Refresh(TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU)