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

from time import time as gettime

    34

from threading import Lock, Timer, currentThread

    35

    36

from six.moves import cPickle, xrange

    37

import wx.lib.buttons

    38

import wx.lib.statbmp

    39

import wx.stc

    40

import wx.adv

    41

    42

    43

import version

    44

from editors.EditorPanel import EditorPanel

    45

from editors.Viewer import Viewer

    46

from editors.TextViewer import TextViewer

    47

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    48

from editors.DataTypeEditor import DataTypeEditor

    49

from util.paths import Bpath

    50

from util.MiniTextControler import MiniTextControler

    51

from util.BitmapLibrary import GetBitmap

    52

from controls.LogViewer import LogViewer

    53

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    54

from controls import EnhancedStatusBar as esb

    55

from dialogs.AboutDialog import ShowAboutDialog

    56

    57

from plcopen.types_enums import \

    58

    ComputeConfigurationName, \

    59

    LOCATION_CONFNODE, \

    60

    LOCATION_MODULE, \

    61

    LOCATION_GROUP, \

    62

    LOCATION_VAR_INPUT, \

    63

    LOCATION_VAR_OUTPUT, \

    64

    LOCATION_VAR_MEMORY, \

    65

    ITEM_PROJECT, \

    66

    ITEM_RESOURCE, \

    67

    ITEM_CONFNODE

    68

    69

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL

    70

    71

from IDEFrame import \

    72

    TITLE,\

    73

    EDITORTOOLBAR,\

    74

    FILEMENU,\

    75

    EDITMENU,\

    76

    DISPLAYMENU,\

    77

    PROJECTTREE,\

    78

    POUINSTANCEVARIABLESPANEL,\

    79

    LIBRARYTREE,\

    80

    PAGETITLES,\

    81

    IDEFrame, \

    82

    EncodeFileSystemPath, \

    83

    DecodeFileSystemPath

    84

    85

from LocalRuntimeMixin import LocalRuntimeMixin

    86

    87

    88

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

    89

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

    90

    91

MAX_RECENT_PROJECTS = 9

    92

    93

    94

if wx.Platform == '__WXMSW__':

    95

    faces = {

    96

        'mono': 'Courier New',

    97

        'size': 8,

    98

    }

    99

else:

   100

    faces = {

   101

        'mono': 'FreeMono',

   102

        'size': 10,

   103

    }

   104

   105

   106

MainThread = currentThread().ident

   107

REFRESH_PERIOD = 0.1

   108

   109

   110

class LogPseudoFile(object):

   111

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

   112

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

   113

        self.red_white = 1

   114

        self.red_yellow = 2

   115

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   116

        self.output = output

   117

        self.risecall = risecall

   118

        # to prevent rapid fire on rising log panel

   119

        self.rising_timer = 0

   120

        self.StackLock = Lock()

   121

        self.YieldLock = Lock()

   122

        self.RefreshLock = Lock()

   123

        self.TimerAccessLock = Lock()

   124

        self.stack = []

   125

        self.LastRefreshTime = gettime()

   126

        self.LastRefreshTimer = None

   127

        self.refreshPending = False

   128

        self.logf = logf

   129

   130

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

   131

        if self.logf is not None:

   132

            self.logf.write(s)

   133

            self.logf.flush()

   134

        self.StackLock.acquire()

   135

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

   136

        self.StackLock.release()

   137

        current_time = gettime()

   138

        with self.TimerAccessLock:

   139

            if self.LastRefreshTimer is not None:

   140

                self.LastRefreshTimer.cancel()

   141

                self.LastRefreshTimer = None

   142

        elapsed = current_time - self.LastRefreshTime

   143

        if elapsed > REFRESH_PERIOD:

   144

            self._should_write()

   145

        else:

   146

            with self.TimerAccessLock:

   147

                if self.LastRefreshTimer is None:

   148

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

   149

                    self.LastRefreshTimer.start()

   150

   151

    def _timer_expired(self):

   152

        self._should_write()

   153

        with self.TimerAccessLock:

   154

            self.LastRefreshTimer = None

   155

   156

    def _should_write(self):

   157

        if MainThread == currentThread().ident:

   158

            app = wx.GetApp()

   159

            if app is not None:

   160

                self._write()

   161

                if self.YieldLock.acquire(0):

   162

                    app.Yield()

   163

                    self.YieldLock.release()

   164

        else:

   165

            with self.RefreshLock:

   166

                if not self.refreshPending:

   167

                    self.refreshPending = True

   168

                    wx.CallAfter(self._write)

   169

   170

    def _write(self):

   171

        if self.output:

   172

            with self.RefreshLock:

   173

                self.output.Freeze()

   174

                self.output.AnnotationClearAll()

   175

                self.StackLock.acquire()

   176

                for s, style in self.stack:

   177

                    if style is None:

   178

                        style = self.black_white

   179

                    if style != self.black_white:

   180

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

   181

   182

                    # Temporary deactivate read only mode on StyledTextCtrl for

   183

                    # adding text. It seems that text modifications, even

   184

                    # programmatically, are disabled in StyledTextCtrl when read

   185

                    # only is active

   186

                    start_pos = self.output.GetLength()

   187

                    self.output.SetReadOnly(False)

   188

                    self.output.AppendText(s)

   189

                    self.output.SetReadOnly(True)

   190

                    text_len = self.output.GetLength() - start_pos

   191

   192

                    if style != self.black_white:

   193

                        self.output.SetStyling(text_len, style)

   194

                self.stack = []

   195

                self.StackLock.release()

   196

                self.output.ScrollToEnd()

   197

                self.output.Thaw()

   198

                self.LastRefreshTime = gettime()

   199

                newtime = time.time()

   200

                if newtime - self.rising_timer > 1:

   201

                    self.risecall(self.output)

   202

                self.rising_timer = newtime

   203

                self.refreshPending = False

   204

   205

   206

    def write_warning(self, s):

   207

        self.write(s, self.red_white)

   208

   209

    def write_error(self, s):

   210

        self.write(s, self.red_yellow)

   211

   212

    def flush(self):

   213

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   214

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

   215

        # disabled in StyledTextCtrl when read only is active

   216

        self.output.SetReadOnly(False)

   217

        self.output.SetText("")

   218

        self.output.SetReadOnly(True)

   219

   220

    def isatty(self):

   221

        return False

   222

   223

    def progress(self, text):

   224

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

   225

        self.output.AnnotationSetText(l, text)

   226

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

   227

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

   228

        if self.YieldLock.acquire(0):

   229

            app = wx.GetApp()

   230

            app.Yield()

   231

            self.YieldLock.release()

   232

   233

   234

ID_FILEMENURECENTPROJECTS = wx.NewId()

   235

   236

   237

class Beremiz(IDEFrame, LocalRuntimeMixin):

   238

   239

    def _init_utils(self):

   240

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

   241

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

   242

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

   243

   244

        IDEFrame._init_utils(self)

   245

   246

    def _init_coll_FileMenu_Items(self, parent):

   247

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

   248

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

   249

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

   250

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

   251

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

   252

        parent.AppendSeparator()

   253

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

   254

   255

        exemples_dir = Bpath("exemples")

   256

        project_list = sorted(os.listdir(exemples_dir))

   257

   258

        for idx, dirname  in enumerate(project_list):

   259

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

   260

   261

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

   262

   263

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

   264

   265

            def OpenExemple(event, projectpath=projectpath):

   266

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

   267

                    return

   268

   269

                self.OpenProject(projectpath)

   270

                if not self.CTR.CheckProjectPathPerm():

   271

                    self.ResetView()

   272

   273

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

   274

        parent.AppendSeparator()

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

        parent.AppendSeparator()

   284

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

   285

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

   286

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

   287

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

   288

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

   289

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

   290

        parent.AppendSeparator()

   291

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

   292

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

   293

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

   305

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

   306

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

   307

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

   308

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

   309

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

   310

   311

    def _RecursiveAddMenuItems(self, menu, items):

   312

        for name, text, helpstr, children in items:

   313

            if len(children) > 0:

   314

                new_menu = wx.Menu(title='')

   315

                menu.AppendSubMenu(new_menu, text)

   316

                self._RecursiveAddMenuItems(new_menu, children)

   317

            else:

   318

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

   319

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

   320

   321

    def _init_coll_AddMenu_Items(self, parent):

   322

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   323

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   324

   325

    def _init_coll_HelpMenu_Items(self, parent):

   326

        def handler(event):

   327

            return wx.MessageBox(

   328

                version.GetCommunityHelpMsg(),

   329

                _(u'Community support'),

   330

                wx.OK | wx.ICON_INFORMATION)

   331

   332

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

   333

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

   334

   335

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

   336

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

   337

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

   338

   339

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   340

        parent.SetFieldsCount(3)

   341

   342

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

   343

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

   344

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

   345

   346

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

   347

   348

    def _init_ctrls(self, prnt):

   349

        IDEFrame._init_ctrls(self, prnt)

   350

   351

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   352

   353

        inspectorID = wx.NewId()

   354

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

   355

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

   356

   357

        self.methodLock = Lock()

   358

   359

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

   360

                                 ("Run",      wx.WXK_F5),

   361

                                 ("Transfer", wx.WXK_F6),

   362

                                 ("Connect",  wx.WXK_F7),

   363

                                 ("Clean",    wx.WXK_F9),

   364

                                 ("Build",    wx.WXK_F11)]:

   365

            def OnMethodGen(obj, meth):

   366

                def OnMethod(evt):

   367

                    if obj.CTR is not None:

   368

                        if obj.methodLock.acquire(False):

   369

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

   370

                            obj.methodLock.release()

   371

                            wx.CallAfter(obj.RefreshStatusToolBar)

   372

                        else:

   373

                            # Postpone call if one of method already running

   374

                            # can happen because of long method using log, 

   375

                            # itself calling wx.Yield

   376

                            wx.CallLater(50, OnMethod, evt)

   377

                return OnMethod

   378

            newid = wx.NewId()

   379

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

   380

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

   381

   382

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   383

   384

        self.LogConsole = CustomStyledTextCtrl(

   385

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

   386

            size=wx.Size(0, 0))

   387

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

   388

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

   389

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

   390

        self.LogConsole.SetReadOnly(True)

   391

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

   392

   393

        # Define Log Console styles

   394

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

   395

        self.LogConsole.StyleClearAll()

   396

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

   397

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

   398

   399

        # Define Log Console markers

   400

        self.LogConsole.SetMarginSensitive(1, True)

   401

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

   402

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

   403

   404

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

   405

        self.LogConsole.SetCaretPeriod(0)

   406

   407

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

   408

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

   409

   410

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

   411

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

   412

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

   413

   414

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

   415

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

   416

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

   417

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

   418

   419

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

   420

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

   421

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

   422

        StatusToolBar.Realize()

   423

        self.Panes["StatusToolBar"] = StatusToolBar

   424

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

   425

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

   426

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

   427

                                LeftDockable(False).RightDockable(False))

   428

   429

        self.AUIManager.Update()

   430

   431

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

   432

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   433

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

   434

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

   435

        self.ProgressStatusBar.Hide()

   436

        self.SetStatusBar(self.ConnectionStatusBar)

   437

   438

    def __init_execute_path(self):

   439

        if os.name == 'nt':

   440

            # on windows, desktop shortcut launches Beremiz.py

   441

            # with working dir set to mingw/bin.

   442

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

   443

            # commands invoked by build process by default are

   444

            # found here.

   445

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

   446

   447

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

   448

   449

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

   450

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

   451

        self.__init_execute_path()

   452

   453

        IDEFrame.__init__(self, parent, debug)

   454

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

   455

   456

        LocalRuntimeMixin.__init__(self, self.Log)

   457

   458

        self.LastPanelSelected = None

   459

   460

        # Define Tree item icon list

   461

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

   462

        self.LocationImageDict = {}

   463

   464

        # Icons for location items

   465

        for imgname, itemtype in [

   466

                ("CONFIGURATION", LOCATION_CONFNODE),

   467

                ("RESOURCE",      LOCATION_MODULE),

   468

                ("PROGRAM",       LOCATION_GROUP),

   469

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   470

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   471

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   472

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

   473

   474

        # Icons for other items

   475

        for imgname, itemtype in [

   476

                ("Extension", ITEM_CONFNODE)]:

   477

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

   478

   479

        if projectOpen is not None:

   480

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   481

   482

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

   483

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

   484

            self.Controler = self.CTR

   485

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

   486

            if not result:

   487

                self.LibraryPanel.SetController(self.Controler)

   488

                self.ProjectTree.Enable(True)

   489

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   490

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

   491

                self.RefreshAfterLoad()

   492

            else:

   493

                self.ResetView()

   494

                self.ShowErrorMessage(result)

   495

        else:

   496

            self.CTR = ctr

   497

            self.Controler = ctr

   498

            if ctr is not None:

   499

                ctr.SetAppFrame(self, self.Log)

   500

                self.LibraryPanel.SetController(self.Controler)

   501

                self.ProjectTree.Enable(True)

   502