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 shutil

    32

import time

    33

import signal

    34

from time import time as gettime

    35

from threading import Lock, Timer, currentThread

    36

    37

from six.moves import cPickle, xrange

    38

import wx.lib.buttons

    39

import wx.lib.statbmp

    40

import wx.stc

    41

import wx.adv

    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.paths import Bpath

    51

from util.MiniTextControler import MiniTextControler

    52

from util.BitmapLibrary import GetBitmap

    53

from controls.LogViewer import LogViewer

    54

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    55

from controls import EnhancedStatusBar as esb

    56

from dialogs.AboutDialog import ShowAboutDialog

    57

    58

from plcopen.types_enums import \

    59

    ComputeConfigurationName, \

    60

    LOCATION_CONFNODE, \

    61

    LOCATION_MODULE, \

    62

    LOCATION_GROUP, \

    63

    LOCATION_VAR_INPUT, \

    64

    LOCATION_VAR_OUTPUT, \

    65

    LOCATION_VAR_MEMORY, \

    66

    ITEM_PROJECT, \

    67

    ITEM_RESOURCE, \

    68

    ITEM_CONFNODE

    69

    70

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL

    71

    72

from IDEFrame import \

    73

    TITLE,\

    74

    EDITORTOOLBAR,\

    75

    FILEMENU,\

    76

    EDITMENU,\

    77

    DISPLAYMENU,\

    78

    PROJECTTREE,\

    79

    POUINSTANCEVARIABLESPANEL,\

    80

    LIBRARYTREE,\

    81

    PAGETITLES,\

    82

    IDEFrame, \

    83

    EncodeFileSystemPath, \

    84

    DecodeFileSystemPath

    85

    86

from LocalRuntimeMixin import LocalRuntimeMixin

    87

    88

    89

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

    90

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

    91

    92

MAX_RECENT_PROJECTS = 9

    93

    94

    95

if wx.Platform == '__WXMSW__':

    96

    faces = {

    97

        'mono': 'Courier New',

    98

        'size': 8,

    99

    }

   100

else:

   101

    faces = {

   102

        'mono': 'FreeMono',

   103

        'size': 10,

   104

    }

   105

   106

   107

MainThread = currentThread().ident

   108

REFRESH_PERIOD = 0.1

   109

   110

   111

class LogPseudoFile(object):

   112

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

   113

    def __init__(self, output, risecall, logf):

   114

        self.red_white = 1

   115

        self.red_yellow = 2

   116

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   117

        self.output = output

   118

        self.risecall = risecall

   119

        # to prevent rapid fire on rising log panel

   120

        self.rising_timer = 0

   121

        self.StackLock = Lock()

   122

        self.YieldLock = Lock()

   123

        self.RefreshLock = Lock()

   124

        self.TimerAccessLock = Lock()

   125

        self.stack = []

   126

        self.LastRefreshTime = gettime()

   127

        self.LastRefreshTimer = None

   128

        self.refreshPending = False

   129

        self.logf = logf

   130

   131

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

   132

        if self.logf is not None:

   133

            self.logf.write(s)

   134

            self.logf.flush()

   135

        self.StackLock.acquire()

   136

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

   137

        self.StackLock.release()

   138

        current_time = gettime()

   139

        with self.TimerAccessLock:

   140

            if self.LastRefreshTimer is not None:

   141

                self.LastRefreshTimer.cancel()

   142

                self.LastRefreshTimer = None

   143

        elapsed = current_time - self.LastRefreshTime

   144

        if elapsed > REFRESH_PERIOD:

   145

            self._should_write()

   146

        else:

   147

            with self.TimerAccessLock:

   148

                if self.LastRefreshTimer is None:

   149

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

   150

                    self.LastRefreshTimer.start()

   151

   152

    def _timer_expired(self):

   153

        self._should_write()

   154

        with self.TimerAccessLock:

   155

            self.LastRefreshTimer = None

   156

   157

    def _should_write(self):

   158

        if MainThread == currentThread().ident:

   159

            app = wx.GetApp()

   160

            if app is not None:

   161

                self._write()

   162

                if self.YieldLock.acquire(0):

   163

                    app.Yield()

   164

                    self.YieldLock.release()

   165

        else:

   166

            with self.RefreshLock:

   167

                if not self.refreshPending:

   168

                    self.refreshPending = True

   169

                    wx.CallAfter(self._write)

   170

   171

    def _write(self):

   172

        if self.output:

   173

            with self.RefreshLock:

   174

                self.output.Freeze()

   175

                self.output.AnnotationClearAll()

   176

                self.StackLock.acquire()

   177

                for s, style in self.stack:

   178

                    if style is None:

   179

                        style = self.black_white

   180

                    if style != self.black_white:

   181

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

   182

   183

                    # Temporary deactivate read only mode on StyledTextCtrl for

   184

                    # adding text. It seems that text modifications, even

   185

                    # programmatically, are disabled in StyledTextCtrl when read

   186

                    # only is active

   187

                    start_pos = self.output.GetLength()

   188

                    self.output.SetReadOnly(False)

   189

                    self.output.AppendText(s)

   190

                    self.output.SetReadOnly(True)

   191

                    text_len = self.output.GetLength() - start_pos

   192

   193

                    if style != self.black_white:

   194

                        self.output.SetStyling(text_len, style)

   195

                self.stack = []

   196

                self.StackLock.release()

   197

                self.output.ScrollToEnd()

   198

                self.output.Thaw()

   199

                self.LastRefreshTime = gettime()

   200

                newtime = time.time()

   201

                if newtime - self.rising_timer > 1:

   202

                    self.risecall(self.output)

   203

                self.rising_timer = newtime

   204

                self.refreshPending = False

   205

   206

   207

    def write_warning(self, s):

   208

        self.write(s, self.red_white)

   209

   210

    def write_error(self, s):

   211

        self.write(s, self.red_yellow)

   212

   213

    def flush(self):

   214

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   215

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

   216

        # disabled in StyledTextCtrl when read only is active

   217

        self.output.SetReadOnly(False)

   218

        self.output.SetText("")

   219

        self.output.SetReadOnly(True)

   220

   221

    def isatty(self):

   222

        return False

   223

   224

    def progress(self, text):

   225

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

   226

        self.output.AnnotationSetText(l, text)

   227

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

   228

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

   229

        if self.YieldLock.acquire(0):

   230

            app = wx.GetApp()

   231

            app.Yield()

   232

            self.YieldLock.release()

   233

   234

   235

ID_FILEMENURECENTPROJECTS = wx.NewId()

   236

   237

   238

class Beremiz(IDEFrame, LocalRuntimeMixin):

   239

   240

    def _init_utils(self):

   241

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

   242

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

   243

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

   244

   245

        IDEFrame._init_utils(self)

   246

   247

    def _init_coll_FileMenu_Items(self, parent):

   248

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

   249

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

   250

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

   251

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

   252

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

   253

        parent.AppendSeparator()

   254

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

   255

   256

        exemples_dir = Bpath("exemples")

   257

        project_list = sorted(os.listdir(exemples_dir))

   258

   259

        for idx, dirname  in enumerate(project_list):

   260

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

   261

   262

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

   263

   264

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

   265

   266

            def OpenExemple(event, projectpath=projectpath):

   267

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

   268

                    return

   269

   270

                self.OpenProject(projectpath)

   271

                if not self.CTR.CheckProjectPathPerm():

   272

                    self.ResetView()

   273

   274

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

   275

        parent.AppendSeparator()

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

        parent.AppendSeparator()

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

        parent.AppendSeparator()

   292

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

   293

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

   294

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

   306

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

   307

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

   308

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

   309

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

   310

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

   311

   312

    def _RecursiveAddMenuItems(self, menu, items):

   313

        for name, text, helpstr, children in items:

   314

            if len(children) > 0:

   315

                new_menu = wx.Menu(title='')

   316

                menu.AppendSubMenu(new_menu, text)

   317

                self._RecursiveAddMenuItems(new_menu, children)

   318

            else:

   319

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

   320

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

   321

   322

    def _init_coll_AddMenu_Items(self, parent):

   323

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   324

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   325

   326

    def _init_coll_HelpMenu_Items(self, parent):

   327

        def handler(event):

   328

            return wx.MessageBox(

   329

                version.GetCommunityHelpMsg(),

   330

                _(u'Community support'),

   331

                wx.OK | wx.ICON_INFORMATION)

   332

   333

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

   334

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

   335

   336

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

   337

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

   338

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

   339

   340

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   341

        parent.SetFieldsCount(3)

   342

   343

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

   344

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

   345

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

   346

   347

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

   348

   349

    def _init_ctrls(self, prnt):

   350

        IDEFrame._init_ctrls(self, prnt)

   351

   352

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   353

   354

        inspectorID = wx.NewId()

   355

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

   356

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

   357

   358

        self.methodLock = Lock()

   359

   360

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

   361

                                 ("Run",      wx.WXK_F5),

   362

                                 ("Transfer", wx.WXK_F6),

   363

                                 ("Connect",  wx.WXK_F7),

   364

                                 ("Clean",    wx.WXK_F9),

   365

                                 ("Build",    wx.WXK_F11)]:

   366

            def OnMethodGen(obj, meth):

   367

                def OnMethod(evt):

   368

                    if obj.CTR is not None:

   369

                        if obj.methodLock.acquire(False):

   370

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

   371

                            obj.methodLock.release()

   372

                            wx.CallAfter(obj.RefreshStatusToolBar)

   373

                        else:

   374

                            # Postpone call if one of method already running

   375

                            # can happen because of long method using log, 

   376

                            # itself calling wx.Yield

   377

                            wx.CallLater(50, OnMethod, evt)

   378

                return OnMethod

   379

            newid = wx.NewId()

   380

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

   381

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

   382

   383

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   384

   385

        self.LogConsole = CustomStyledTextCtrl(

   386

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

   387

            size=wx.Size(0, 0))

   388

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

   389

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

   390

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

   391

        self.LogConsole.SetReadOnly(True)

   392

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

   393

   394

        # Define Log Console styles

   395

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

   396

        self.LogConsole.StyleClearAll()

   397

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

   398

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

   399

   400

        # Define Log Console markers

   401

        self.LogConsole.SetMarginSensitive(1, True)

   402

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

   403

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

   404

   405

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

   406

        self.LogConsole.SetCaretPeriod(0)

   407

   408

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

   409

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

   410

   411

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

   412

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

   413

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

   414

   415

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

   416

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

   417

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

   418

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

   419

   420

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

   421

                                   wx.TB_FLAT | wx.TB_HORIZONTAL | wx.NO_BORDER)

   422

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

   423

        StatusToolBar.Realize()

   424

        self.Panes["StatusToolBar"] = StatusToolBar

   425

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

   426

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

   427

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

   428

                                LeftDockable(False).RightDockable(False))

   429

   430

        self.AUIManager.Update()

   431

   432

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

   433

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   434

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

   435

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

   436

        self.ProgressStatusBar.Hide()

   437

        self.SetStatusBar(self.ConnectionStatusBar)

   438

   439

    def __init_execute_path(self):

   440

        if os.name == 'nt':

   441

            # on windows, desktop shortcut launches Beremiz.py

   442

            # with working dir set to mingw/bin.

   443

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

   444

            # commands invoked by build process by default are

   445

            # found here.

   446

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

   447

   448

    def __init__(self, parent, projectOpen=None, buildpath=None, ctr=None, debug=True, logf=None):

   449

   450

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

   451

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

   452

        self.__init_execute_path()

   453

   454

        IDEFrame.__init__(self, parent, debug)

   455

        self.Log = LogPseudoFile(self.LogConsole, self.SelectTab, logf)

   456

   457

        LocalRuntimeMixin.__init__(self, self.Log)

   458

   459

        self.LastPanelSelected = None

   460

   461

        # Define Tree item icon list

   462

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

   463

        self.LocationImageDict = {}

   464

   465

        # Icons for location items

   466

        for imgname, itemtype in [

   467

                ("CONFIGURATION", LOCATION_CONFNODE),

   468

                ("RESOURCE",      LOCATION_MODULE),

   469

                ("PROGRAM",       LOCATION_GROUP),

   470

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   471

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   472

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   473

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

   474

   475

        # Icons for other items

   476

        for imgname, itemtype in [

   477

                ("Extension", ITEM_CONFNODE)]:

   478

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

   479

   480

        if projectOpen is not None:

   481

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   482

   483

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

   484

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

   485

            self.Controler = self.CTR

   486

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

   487

            if not result:

   488

                self.LibraryPanel.SetController(self.Controler)

   489

                self.ProjectTree.Enable(True)

   490

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   491

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

   492

                self.RefreshAfterLoad()

   493

            else:

   494

                self.ResetView()

   495

                self.ShowErrorMessage(result)

   496

        else:

   497

            self.CTR = ctr

   498

            self.Controler = ctr

   499

            if ctr is not None:

   500

                ctr.SetAppFrame(self, self.Log)

   501

                self.LibraryPanel.SetController(self.Controler)

   502