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

    41

    42

import version

    43

from editors.EditorPanel import EditorPanel

    44

from editors.Viewer import Viewer

    45

from editors.TextViewer import TextViewer

    46

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    47

from editors.DataTypeEditor import DataTypeEditor

    48

from util.paths import Bpath

    49

from util.MiniTextControler import MiniTextControler

    50

from util.BitmapLibrary import GetBitmap

    51

from controls.LogViewer import LogViewer

    52

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    53

from controls import EnhancedStatusBar as esb

    54

from dialogs.AboutDialog import ShowAboutDialog

    55

    56

from plcopen.types_enums import \

    57

    ComputeConfigurationName, \

    58

    LOCATION_CONFNODE, \

    59

    LOCATION_MODULE, \

    60

    LOCATION_GROUP, \

    61

    LOCATION_VAR_INPUT, \

    62

    LOCATION_VAR_OUTPUT, \

    63

    LOCATION_VAR_MEMORY, \

    64

    ITEM_PROJECT, \

    65

    ITEM_RESOURCE, \

    66

    ITEM_CONFNODE

    67

    68

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL

    69

    70

from IDEFrame import \

    71

    TITLE,\

    72

    EDITORTOOLBAR,\

    73

    FILEMENU,\

    74

    EDITMENU,\

    75

    DISPLAYMENU,\

    76

    PROJECTTREE,\

    77

    POUINSTANCEVARIABLESPANEL,\

    78

    LIBRARYTREE,\

    79

    PAGETITLES,\

    80

    IDEFrame, \

    81

    EncodeFileSystemPath, \

    82

    DecodeFileSystemPath

    83

    84

from LocalRuntimeMixin import LocalRuntimeMixin

    85

    86

    87

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

    88

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

    89

    90

MAX_RECENT_PROJECTS = 9

    91

    92

    93

if wx.Platform == '__WXMSW__':

    94

    faces = {

    95

        'mono': 'Courier New',

    96

        'size': 8,

    97

    }

    98

else:

    99

    faces = {

   100

        'mono': 'FreeMono',

   101

        'size': 10,

   102

    }

   103

   104

   105

MainThread = currentThread().ident

   106

REFRESH_PERIOD = 0.1

   107

   108

   109

class LogPseudoFile(object):

   110

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

   111

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

   112

        self.red_white = 1

   113

        self.red_yellow = 2

   114

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   115

        self.output = output

   116

        self.risecall = risecall

   117

        # to prevent rapid fire on rising log panel

   118

        self.rising_timer = 0

   119

        self.StackLock = Lock()

   120

        self.YieldLock = Lock()

   121

        self.RefreshLock = Lock()

   122

        self.TimerAccessLock = Lock()

   123

        self.stack = []

   124

        self.LastRefreshTime = gettime()

   125

        self.LastRefreshTimer = None

   126

        self.refreshPending = False

   127

        self.logf = logf

   128

   129

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

   130

        if self.logf is not None:

   131

            self.logf.write(s)

   132

            self.logf.flush()

   133

        self.StackLock.acquire()

   134

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

   135

        self.StackLock.release()

   136

        current_time = gettime()

   137

        with self.TimerAccessLock:

   138

            if self.LastRefreshTimer is not None:

   139

                self.LastRefreshTimer.cancel()

   140

                self.LastRefreshTimer = None

   141

        elapsed = current_time - self.LastRefreshTime

   142

        if elapsed > REFRESH_PERIOD:

   143

            self._should_write()

   144

        else:

   145

            with self.TimerAccessLock:

   146

                if self.LastRefreshTimer is None:

   147

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

   148

                    self.LastRefreshTimer.start()

   149

   150

    def _timer_expired(self):

   151

        self._should_write()

   152

        with self.TimerAccessLock:

   153

            self.LastRefreshTimer = None

   154

   155

    def _should_write(self):

   156

        if MainThread == currentThread().ident:

   157

            app = wx.GetApp()

   158

            if app is not None:

   159

                self._write()

   160

                if self.YieldLock.acquire(0):

   161

                    app.Yield()

   162

                    self.YieldLock.release()

   163

        else:

   164

            with self.RefreshLock:

   165

                if not self.refreshPending:

   166

                    self.refreshPending = True

   167

                    wx.CallAfter(self._write)

   168

   169

    def _write(self):

   170

        if self.output:

   171

            with self.RefreshLock:

   172

                self.output.Freeze()

   173

                self.output.AnnotationClearAll()

   174

                self.StackLock.acquire()

   175

                for s, style in self.stack:

   176

                    if style is None:

   177

                        style = self.black_white

   178

                    if style != self.black_white:

   179

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

   180

   181

                    # Temporary deactivate read only mode on StyledTextCtrl for

   182

                    # adding text. It seems that text modifications, even

   183

                    # programmatically, are disabled in StyledTextCtrl when read

   184

                    # only is active

   185

                    start_pos = self.output.GetLength()

   186

                    self.output.SetReadOnly(False)

   187

                    self.output.AppendText(s)

   188

                    self.output.SetReadOnly(True)

   189

                    text_len = self.output.GetLength() - start_pos

   190

   191

                    if style != self.black_white:

   192

                        self.output.SetStyling(text_len, style)

   193

                self.stack = []

   194

                self.StackLock.release()

   195

                self.output.ScrollToEnd()

   196

                self.output.Thaw()

   197

                self.LastRefreshTime = gettime()

   198

                newtime = time.time()

   199

                if newtime - self.rising_timer > 1:

   200

                    self.risecall(self.output)

   201

                self.rising_timer = newtime

   202

                self.refreshPending = False

   203

   204

   205

    def write_warning(self, s):

   206

        self.write(s, self.red_white)

   207

   208

    def write_error(self, s):

   209

        self.write(s, self.red_yellow)

   210

   211

    def flush(self):

   212

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   213

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

   214

        # disabled in StyledTextCtrl when read only is active

   215

        self.output.SetReadOnly(False)

   216

        self.output.SetText("")

   217

        self.output.SetReadOnly(True)

   218

   219

    def isatty(self):

   220

        return False

   221

   222

    def progress(self, text):

   223

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

   224

        self.output.AnnotationSetText(l, text)

   225

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

   226

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

   227

        if self.YieldLock.acquire(0):

   228

            app = wx.GetApp()

   229

            app.Yield()

   230

            self.YieldLock.release()

   231

   232

   233

ID_FILEMENURECENTPROJECTS = wx.NewId()

   234

   235

   236

class Beremiz(IDEFrame, LocalRuntimeMixin):

   237

   238

    def _init_utils(self):

   239

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

   240

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

   241

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

   242

   243

        IDEFrame._init_utils(self)

   244

   245

    def _init_coll_FileMenu_Items(self, parent):

   246

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

   247

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

   248

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

   249

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

   250

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

   251

        parent.AppendSeparator()

   252

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

   253

   254

        exemples_dir = Bpath("exemples")

   255

        project_list = sorted(os.listdir(exemples_dir))

   256

   257

        for idx, dirname  in enumerate(project_list):

   258

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

   259

   260

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

   261

   262

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

   263

   264

            def OpenExemple(event, projectpath=projectpath):

   265

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

   266

                    return

   267

   268

                self.OpenProject(projectpath)

   269

                if not self.CTR.CheckProjectPathPerm():

   270

                    self.ResetView()

   271

   272

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

   273

        parent.AppendSeparator()

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

        parent.AppendSeparator()

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

        parent.AppendSeparator()

   290

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

   291

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

   292

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

   304

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

   305

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

   306

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

   307

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

   308

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

   309

   310

    def _RecursiveAddMenuItems(self, menu, items):

   311

        for name, text, helpstr, children in items:

   312

            if len(children) > 0:

   313

                new_menu = wx.Menu(title='')

   314

                menu.AppendSubMenu(new_menu, text)

   315

                self._RecursiveAddMenuItems(new_menu, children)

   316

            else:

   317

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

   318

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

   319

   320

    def _init_coll_AddMenu_Items(self, parent):

   321

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   322

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   323

   324

    def _init_coll_HelpMenu_Items(self, parent):

   325

        def handler(event):

   326

            return wx.MessageBox(

   327

                version.GetCommunityHelpMsg(),

   328

                _(u'Community support'),

   329

                wx.OK | wx.ICON_INFORMATION)

   330

   331

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

   332

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

   333

   334

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

   335

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

   336

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

   337

   338

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   339

        parent.SetFieldsCount(3)

   340

   341

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

   342

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

   343

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

   344

   345

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

   346

   347

    def _init_ctrls(self, prnt):

   348

        IDEFrame._init_ctrls(self, prnt)

   349

   350

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   351

   352

        inspectorID = wx.NewId()

   353

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

   354

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

   355

   356

        self.methodLock = Lock()

   357

   358

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

   359

                                 ("Run",      wx.WXK_F5),

   360

                                 ("Transfer", wx.WXK_F6),

   361

                                 ("Connect",  wx.WXK_F7),

   362

                                 ("Clean",    wx.WXK_F9),

   363

                                 ("Build",    wx.WXK_F11)]:

   364

            def OnMethodGen(obj, meth):

   365

                def OnMethod(evt):

   366

                    if obj.CTR is not None:

   367

                        if obj.methodLock.acquire(False):

   368

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

   369

                            obj.methodLock.release()

   370

                            wx.CallAfter(obj.RefreshStatusToolBar)

   371

                        else:

   372

                            # Postpone call if one of method already running

   373

                            # can happen because of long method using log, 

   374

                            # itself calling wx.Yield

   375

                            wx.CallLater(50, OnMethod, evt)

   376

                return OnMethod

   377

            newid = wx.NewId()

   378

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

   379

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

   380

   381

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   382

   383

        self.LogConsole = CustomStyledTextCtrl(

   384

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

   385

            size=wx.Size(0, 0))

   386

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

   387

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

   388

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

   389

        self.LogConsole.SetReadOnly(True)

   390

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

   391

   392

        # Define Log Console styles

   393

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

   394

        self.LogConsole.StyleClearAll()

   395

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

   396

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

   397

   398

        # Define Log Console markers

   399

        self.LogConsole.SetMarginSensitive(1, True)

   400

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

   401

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

   402

   403

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

   404

        self.LogConsole.SetCaretPeriod(0)

   405

   406

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

   407

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

   408

   409

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

   410

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

   411

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

   412

   413

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

   414

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

   415

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

   416

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

   417

   418

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

   419

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

   420

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

   421

        StatusToolBar.Realize()

   422

        self.Panes["StatusToolBar"] = StatusToolBar

   423

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

   424

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

   425

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

   426

                                LeftDockable(False).RightDockable(False))

   427

   428

        self.AUIManager.Update()

   429

   430

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

   431

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   432

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

   433

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

   434

        self.ProgressStatusBar.Hide()

   435

        self.SetStatusBar(self.ConnectionStatusBar)

   436

   437

    def __init_execute_path(self):

   438

        if os.name == 'nt':

   439

            # on windows, desktop shortcut launches Beremiz.py

   440

            # with working dir set to mingw/bin.

   441

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

   442

            # commands invoked by build process by default are

   443

            # found here.

   444

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

   445

   446

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

   447

   448

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

   449

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

   450

        self.__init_execute_path()

   451

   452

        IDEFrame.__init__(self, parent, debug)

   453

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

   454

   457

        self.LastPanelSelected = None

   458

   459

        # Define Tree item icon list

   460

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

   461

        self.LocationImageDict = {}

   462

   463

        # Icons for location items

   464

        for imgname, itemtype in [

   465

                ("CONFIGURATION", LOCATION_CONFNODE),

   466

                ("RESOURCE",      LOCATION_MODULE),

   467

                ("PROGRAM",       LOCATION_GROUP),

   468

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   469

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   470

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   471

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

   472

   473

        # Icons for other items

   474

        for imgname, itemtype in [

   475

                ("Extension", ITEM_CONFNODE)]:

   476

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

   477

   478

        if projectOpen is not None:

   479

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   480

   481

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

   482

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

   483

            self.Controler = self.CTR

   484

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

   485

            if not result:

   486

                self.LibraryPanel.SetController(self.Controler)

   487

                self.ProjectTree.Enable(True)

   488

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   489

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

   490

                self.RefreshAfterLoad()

   491

            else:

   492

                self.ResetView()

   493

                self.ShowErrorMessage(result)

   494

        else:

   495

            self.CTR = ctr

   496

            self.Controler = ctr

   497

            if ctr is not None:

   498

                ctr.SetAppFrame(self, self.Log)

   499

                self.LibraryPanel.SetController(self.Controler)

   500

                self.ProjectTree.Enable(True)

   501

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   502