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."""

   118

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

   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

   134

        self.logf = logf

   135

   136

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

   137

        if self.logf is not None:

   138

            self.logf.write(s)

   139

            self.logf.flush()

   140

        self.StackLock.acquire()

   141

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

   142

        self.StackLock.release()

   143

        current_time = gettime()

   144

        with self.TimerAccessLock:

   145

            if self.LastRefreshTimer is not None:

   146

                self.LastRefreshTimer.cancel()

   147

                self.LastRefreshTimer = None

   148

        elapsed = current_time - self.LastRefreshTime

   149

        if elapsed > REFRESH_PERIOD:

   150

            self._should_write()

   151

        else:

   152

            with self.TimerAccessLock:

   153

                if self.LastRefreshTimer is None:

   154

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

   155

                    self.LastRefreshTimer.start()

   156

   157

    def _timer_expired(self):

   158

        self._should_write()

   159

        with self.TimerAccessLock:

   160

            self.LastRefreshTimer = None

   161

   162

    def _should_write(self):

   163

        if MainThread == currentThread().ident:

   164

            app = wx.GetApp()

   165

            if app is not None:

   166

                self._write()

   167

                if self.YieldLock.acquire(0):

   168

                    app.Yield()

   169

                    self.YieldLock.release()

   170

        else:

   171

            with self.RefreshLock:

   172

                if not self.refreshPending:

   173

                    self.refreshPending = True

   174

                    wx.CallAfter(self._write)

   175

   176

    def _write(self):

   177

        if self.output:

   178

            with self.RefreshLock:

   179

                self.output.Freeze()

   180

                self.output.AnnotationClearAll()

   181

                self.StackLock.acquire()

   182

                for s, style in self.stack:

   183

                    if style is None:

   184

                        style = self.black_white

   185

                    if style != self.black_white:

   186

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

   187

   188

                    # Temporary deactivate read only mode on StyledTextCtrl for

   189

                    # adding text. It seems that text modifications, even

   190

                    # programmatically, are disabled in StyledTextCtrl when read

   191

                    # only is active

   192

                    start_pos = self.output.GetLength()

   193

                    self.output.SetReadOnly(False)

   194

                    self.output.AppendText(s)

   195

                    self.output.SetReadOnly(True)

   196

                    text_len = self.output.GetLength() - start_pos

   197

   198

                    if style != self.black_white:

   199

                        self.output.SetStyling(text_len, style)

   200

                self.stack = []

   201

                self.StackLock.release()

   202

                self.output.ScrollToEnd()

   203

                self.output.Thaw()

   204

                self.LastRefreshTime = gettime()

   205

                newtime = time.time()

   206

                if newtime - self.rising_timer > 1:

   207

                    self.risecall(self.output)

   208

                self.rising_timer = newtime

   209

                self.refreshPending = False

   210

   211

   212

    def write_warning(self, s):

   213

        self.write(s, self.red_white)

   214

   215

    def write_error(self, s):

   216

        self.write(s, self.red_yellow)

   217

   218

    def flush(self):

   219

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   220

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

   221

        # disabled in StyledTextCtrl when read only is active

   222

        self.output.SetReadOnly(False)

   223

        self.output.SetText("")

   224

        self.output.SetReadOnly(True)

   225

   226

    def isatty(self):

   227

        return False

   228

   229

    def progress(self, text):

   230

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

   231

        self.output.AnnotationSetText(l, text)

   232

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

   233

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

   234

        if self.YieldLock.acquire(0):

   235

            app = wx.GetApp()

   236

            app.Yield()

   237

            self.YieldLock.release()

   238

   239

   240

ID_FILEMENURECENTPROJECTS = wx.NewId()

   241

   242

   243

class Beremiz(IDEFrame):

   244

   245

    def _init_utils(self):

   246

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

   247

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

   248

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

   249

   250

        IDEFrame._init_utils(self)

   251

   252

    def _init_coll_FileMenu_Items(self, parent):

   253

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

   254

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

   255

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

   256

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

   257

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

   258

        parent.AppendSeparator()

   259

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

   260

   261

        exemples_dir = Bpath("exemples")

   262

        project_list = sorted(os.listdir(exemples_dir))

   263

   264

        for idx, dirname  in enumerate(project_list):

   265

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

   266

   267

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

   268

   269

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

   270

   271

            def OpenExemple(event, projectpath=projectpath):

   272

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

   273

                    return

   274

   275

                self.OpenProject(projectpath)

   276

                if not self.CTR.CheckProjectPathPerm():

   277

                    self.ResetView()

   278

   279

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

   280

        parent.AppendSeparator()

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

        parent.AppendSeparator()

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

        parent.AppendSeparator()

   297

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

   298

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

   299

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

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

   309

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

   310

   311

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

   312

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

   313

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

   314

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

   315

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

   316

   317

    def _RecursiveAddMenuItems(self, menu, items):

   318

        for name, text, helpstr, children in items:

   319

            if len(children) > 0:

   320

                new_menu = wx.Menu(title='')

   321

                menu.AppendSubMenu(new_menu, text)

   322

                self._RecursiveAddMenuItems(new_menu, children)

   323

            else:

   324

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

   325

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

   326

   327

    def _init_coll_AddMenu_Items(self, parent):

   328

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   329

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   330

   331

    def _init_coll_HelpMenu_Items(self, parent):

   332

        def handler(event):

   333

            return wx.MessageBox(

   334

                version.GetCommunityHelpMsg(),

   335

                _(u'Community support'),

   336

                wx.OK | wx.ICON_INFORMATION)

   337

   338

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

   339

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

   340

   341

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

   342

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

   343

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

   344

   345

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   346

        parent.SetFieldsCount(3)

   347

   348

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

   349

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

   350

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

   351

   352

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

   353

   354

    def _init_ctrls(self, prnt):

   355

        IDEFrame._init_ctrls(self, prnt)

   356

   357

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   358

   359

        inspectorID = wx.NewId()

   360

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

   361

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

   362

   363

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

   364

                                 ("Run",      wx.WXK_F5),

   365

                                 ("Transfer", wx.WXK_F6),

   366

                                 ("Connect",  wx.WXK_F7),

   367

                                 ("Clean",    wx.WXK_F9),

   368

                                 ("Build",    wx.WXK_F11)]:

   369

            def OnMethodGen(obj, meth):

   370

                def OnMethod(evt):

   371

                    if obj.CTR is not None:

   372

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

   373

                    wx.CallAfter(self.RefreshStatusToolBar)

   374

                return OnMethod

   375

            newid = wx.NewId()

   376

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

   377

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

   378

   379

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   380

   381

        self.LogConsole = CustomStyledTextCtrl(

   382

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

   383

            size=wx.Size(0, 0))

   384

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

   385

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

   386

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

   387

        self.LogConsole.SetReadOnly(True)

   388

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

   389

   390

        # Define Log Console styles

   391

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

   392

        self.LogConsole.StyleClearAll()

   393

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

   394

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

   395

   396

        # Define Log Console markers

   397

        self.LogConsole.SetMarginSensitive(1, True)

   398

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

   399

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

   400

   401

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

   402

        self.LogConsole.SetCaretPeriod(0)

   403

   404

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

   405

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

   406

   407

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

   408

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

   409

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

   410

   411

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

   412

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

   413

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

   414

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

   415

   416

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

   417

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

   418

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

   419

        StatusToolBar.Realize()

   420

        self.Panes["StatusToolBar"] = StatusToolBar

   421

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

   422

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

   423

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

   424

                                LeftDockable(False).RightDockable(False))

   425

   426

        self.AUIManager.Update()

   427

   428

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

   429

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   430

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

   431

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

   432

        self.ProgressStatusBar.Hide()

   433

        self.SetStatusBar(self.ConnectionStatusBar)

   434

   435

    def __init_execute_path(self):

   436

        if os.name == 'nt':

   437

            # on windows, desktop shortcut launches Beremiz.py

   438

            # with working dir set to mingw/bin.

   439

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

   440

            # commands invoked by build process by default are

   441

            # found here.

   442

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

   443

   444

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

   445

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

   446

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

   447

        self.__init_execute_path()

   448

   449

        IDEFrame.__init__(self, parent, debug)

   450

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

   451

   452

        self.local_runtime = None

   453

        self.runtime_port = None

   454

        self.local_runtime_tmpdir = None

   455

   456

        self.LastPanelSelected = None

   457

   458

        # Define Tree item icon list

   459

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

   460

        self.LocationImageDict = {}

   461

   462

        # Icons for location items

   463

        for imgname, itemtype in [

   464

                ("CONFIGURATION", LOCATION_CONFNODE),

   465

                ("RESOURCE",      LOCATION_MODULE),

   466

                ("PROGRAM",       LOCATION_GROUP),

   467

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   468

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   469

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   470

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

   471

   472

        # Icons for other items

   473

        for imgname, itemtype in [

   474

                ("Extension", ITEM_CONFNODE)]:

   475

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

   476

   477

        if projectOpen is not None:

   478

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   479

   480

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

   481

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

   482

            self.Controler = self.CTR

   483

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

   484

            if not result:

   485

                self.LibraryPanel.SetController(self.Controler)

   486

                self.ProjectTree.Enable(True)

   487

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   488

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

   489

                self.RefreshAfterLoad()

   490

            else:

   491

                self.ResetView()

   492

                self.ShowErrorMessage(result)

   493

        else:

   494

            self.CTR = ctr

   495

            self.Controler = ctr

   496

            if ctr is not None:

   497

                ctr.SetAppFrame(self, self.Log)

   498

                self.LibraryPanel.SetController(self.Controler)

   499

                self.ProjectTree.Enable(True)

   500

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   501

                self.RefreshAfterLoad()

   502

        if self.EnableDebug:

   503

            self.DebugVariablePanel.SetDataProducer(self.CTR)