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

import os, sys

    28

import tempfile

    29

import shutil

    30

import random

    31

import time

    32

import version

    33

from types import ListType

    34

    35

beremiz_dir = os.path.dirname(os.path.realpath(__file__))

    36

    37

def Bpath(*args):

    38

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

    39

    40

    41

    42

import wx.lib.buttons, wx.lib.statbmp, wx.stc

    43

import cPickle

    44

import types, time, re, platform, time, traceback, commands

    45

    46

from docutil import OpenHtmlFrame

    47

from editors.EditorPanel import EditorPanel

    48

from editors.Viewer import Viewer

    49

from editors.TextViewer import TextViewer

    50

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    51

from editors.DataTypeEditor import DataTypeEditor

    52

from util.MiniTextControler import MiniTextControler

    53

from util.ProcessLogger import ProcessLogger

    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 PLCControler import LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY, ITEM_PROJECT, ITEM_RESOURCE

    60

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    61

    62

    63

MAX_RECENT_PROJECTS = 9

    64

    65

if wx.Platform == '__WXMSW__':

    66

    faces = {

    67

        'mono' : 'Courier New',

    68

        'size' : 8,

    69

    }

    70

else:

    71

    faces = {

    72

        'mono' : 'Courier',

    73

        'size' : 10,

    74

    }

    75

    76

from threading import Lock,Timer,currentThread

    77

MainThread = currentThread().ident

    78

REFRESH_PERIOD = 0.1

    79

from time import time as gettime

    80

class LogPseudoFile:

    81

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

    82

    def __init__(self, output, risecall):

    83

        self.red_white = 1

    84

        self.red_yellow = 2

    85

        self.black_white = wx.stc.STC_STYLE_DEFAULT

    86

        self.output = output

    87

        self.risecall = risecall

    88

        # to prevent rapid fire on rising log panel

    89

        self.rising_timer = 0

    90

        self.lock = Lock()

    91

        self.YieldLock = Lock()

    92

        self.RefreshLock = Lock()

    93

        self.TimerAccessLock = Lock()

    94

        self.stack = []

    95

        self.LastRefreshTime = gettime()

    96

        self.LastRefreshTimer = None

    97

    98

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

    99

        if self.lock.acquire():

   100

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

   101

            self.lock.release()

   102

            current_time = gettime()

   103

            self.TimerAccessLock.acquire()

   104

            if self.LastRefreshTimer:

   105

                self.LastRefreshTimer.cancel()

   106

                self.LastRefreshTimer=None

   107

            self.TimerAccessLock.release()

   108

            if current_time - self.LastRefreshTime > REFRESH_PERIOD and self.RefreshLock.acquire(False):

   109

                self._should_write()

   110

            else:

   111

                self.TimerAccessLock.acquire()

   112

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

   113

                self.LastRefreshTimer.start()

   114

                self.TimerAccessLock.release()

   115

   116

    def _timer_expired(self):

   117

        if self.RefreshLock.acquire(False):

   118

            self._should_write()

   119

        else:

   120

            self.TimerAccessLock.acquire()

   121

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

   122

            self.LastRefreshTimer.start()

   123

            self.TimerAccessLock.release()

   124

   125

    def _should_write(self):

   126

        wx.CallAfter(self._write)

   127

        if MainThread == currentThread().ident:

   128

            app = wx.GetApp()

   129

            if app is not None:

   130

                if self.YieldLock.acquire(0):

   131

                    app.Yield()

   132

                    self.YieldLock.release()

   133

   134

    def _write(self):

   135

        if self.output :

   136

            self.output.Freeze()

   137

            self.lock.acquire()

   138

            for s, style in self.stack:

   139

                if style is None : style=self.black_white

   140

                if style != self.black_white:

   141

                    self.output.StartStyling(self.output.GetLength(), 0xff)

   142

   143

                # Temporary deactivate read only mode on StyledTextCtrl for

   144

                # adding text. It seems that text modifications, even

   145

                # programmatically, are disabled in StyledTextCtrl when read

   146

                # only is active

   147

                start_pos = self.output.GetLength()

   148

                self.output.SetReadOnly(False)

   149

                self.output.AppendText(s)

   150

                self.output.SetReadOnly(True)

   151

                text_len = self.output.GetLength() - start_pos

   152

   153

                if style != self.black_white:

   154

                    self.output.SetStyling(text_len, style)

   155

            self.stack = []

   156

            self.lock.release()

   157

            self.output.Thaw()

   158

            self.LastRefreshTime = gettime()

   159

            try:

   160

                self.RefreshLock.release()

   161

            except:

   162

                pass

   163

            newtime = time.time()

   164

            if newtime - self.rising_timer > 1:

   165

                self.risecall(self.output)

   166

            self.rising_timer = newtime

   167

   168

    def write_warning(self, s):

   169

        self.write(s,self.red_white)

   170

   171

    def write_error(self, s):

   172

        self.write(s,self.red_yellow)

   173

   174

    def writeyield(self, s):

   175

        self.write(s)

   176

        wx.GetApp().Yield()

   177

   178

    def flush(self):

   179

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   180

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

   181

        # disabled in StyledTextCtrl when read only is active

   182

        self.output.SetReadOnly(False)

   183

        self.output.SetText("")

   184

        self.output.SetReadOnly(True)

   185

   186

    def isatty(self):

   187

        return False

   188

   189

ID_FILEMENURECENTPROJECTS = wx.NewId()

   190

   191

from IDEFrame import TITLE,\

   192

                     EDITORTOOLBAR,\

   193

                     FILEMENU,\

   194

                     EDITMENU,\

   195

                     DISPLAYMENU,\

   196

                     PROJECTTREE,\

   197

                     POUINSTANCEVARIABLESPANEL,\

   198

                     LIBRARYTREE,\

   199

                     SCALING,\

   200

                     PAGETITLES,\

   201

                     IDEFrame, AppendMenu,\

   202

                     EncodeFileSystemPath, DecodeFileSystemPath

   203

from util.BitmapLibrary import GetBitmap

   204

   205

class Beremiz(IDEFrame):

   206

   207

    def _init_utils(self):

   208

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

   209

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

   210

   211

        IDEFrame._init_utils(self)

   212

   213

    def _init_coll_FileMenu_Items(self, parent):

   214

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

   215

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

   216

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

   217

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

   218

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

   219

        parent.AppendSeparator()

   220

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

   221

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

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

        parent.AppendSeparator()

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

        parent.AppendSeparator()

   236

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

   237

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

   238

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

   250

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

   251

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

   252

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

   253

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

   254

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

   255

   256

    def _RecursiveAddMenuItems(self, menu, items):

   257

        for name, text, help, children in items:

   258

            new_id = wx.NewId()

   259

            if len(children) > 0:

   260

                new_menu = wx.Menu(title='')

   261

                menu.AppendMenu(new_id, text, new_menu)

   262

                self._RecursiveAddMenuItems(new_menu, children)

   263

            else:

   264

                AppendMenu(menu, help=help, id=new_id,

   265

                       kind=wx.ITEM_NORMAL, text=text)

   266

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

   267

                          id=new_id)

   268

   269

    def _init_coll_AddMenu_Items(self, parent):

   270

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   271

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   272

   273

    def _init_coll_HelpMenu_Items(self, parent):

   274

        parent.Append(help='', id=wx.ID_ABOUT,

   275

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

   276

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

   277

   278

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   279

        parent.SetFieldsCount(3)

   280

   281

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

   282

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

   283

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

   284

   285

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

   286

   287

    def _init_ctrls(self, prnt):

   288

        IDEFrame._init_ctrls(self, prnt)

   289

   290

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   291

   292

        inspectorID = wx.NewId()

   293

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

   294

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

   295

   296

        keyID = wx.NewId()

   297

        self.Bind(wx.EVT_MENU, self.SwitchFullScrMode, id=keyID)

   298

        accels += [wx.AcceleratorEntry(wx.ACCEL_NORMAL, wx.WXK_F12, keyID)]

   299

   300

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

   301

                                ("Run",      wx.WXK_F5),

   302

                                ("Transfer", wx.WXK_F6),

   303

                                ("Connect",  wx.WXK_F7),

   304

                                ("Build",    wx.WXK_F11)]:

   305

            def OnMethodGen(obj,meth):

   306

                def OnMethod(evt):

   307

                    if obj.CTR is not None:

   308

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

   309

                    wx.CallAfter(self.RefreshStatusToolBar)

   310

                return OnMethod

   311

            newid = wx.NewId()

   312

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

   313

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

   314

   315

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   316

   317

        self.LogConsole = CustomStyledTextCtrl(

   318

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

   319

                  size=wx.Size(0, 0))

   320

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

   321

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

   322

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

   323

        self.LogConsole.SetReadOnly(True)

   324

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

   325

   326

        # Define Log Console styles

   327

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

   328

        self.LogConsole.StyleClearAll()

   329

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

   330

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

   331

   332

        # Define Log Console markers

   333

        self.LogConsole.SetMarginSensitive(1, True)

   334

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

   335

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

   336

   337

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

   338

   339

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

   340

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

   341

   342

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

   343

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

   344

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

   345

   346

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

   347

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

   348

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

   349

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

   350

   351

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

   352

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

   353

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

   354

        StatusToolBar.Realize()

   355

        self.Panes["StatusToolBar"] = StatusToolBar

   356

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

   357

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

   358

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

   359

                  LeftDockable(False).RightDockable(False))

   360

   361

        self.AUIManager.Update()

   362

   363

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

   364

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   365

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

   366

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

   367

        self.ProgressStatusBar.Hide()

   368

        self.SetStatusBar(self.ConnectionStatusBar)

   369

   370

    def __init_execute_path(self):

   371

        if os.name == 'nt':

   372

            # on windows, desktop shortcut launches Beremiz.py

   373

            # with working dir set to mingw/bin.

   374

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

   375

            # commands invoked by build process by default are

   376

            # found here.

   377

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

   378

   379

   380

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

   381

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

   382

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

   383

        self.__init_execute_path()

   384

   385

        IDEFrame.__init__(self, parent, debug)

   386

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

   387

   388

        self.local_runtime = None

   389

        self.runtime_port = None

   390

        self.local_runtime_tmpdir = None

   391

   392

        self.LastPanelSelected = None

   393

   394

        # Define Tree item icon list

   395

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

   396

        self.LocationImageDict = {}

   397

   398

        # Icons for location items

   399

        for imgname, itemtype in [

   400

            ("CONFIGURATION", LOCATION_CONFNODE),

   401

            ("RESOURCE",      LOCATION_MODULE),

   402

            ("PROGRAM",       LOCATION_GROUP),

   403

            ("VAR_INPUT",     LOCATION_VAR_INPUT),

   404

            ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   405

            ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   406

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

   407

   408

        # Icons for other items

   409

        for imgname, itemtype in [

   410

            ("Extension", ITEM_CONFNODE)]:

   411

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

   412

   413

        if projectOpen is not None:

   414

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   415

   416

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

   417

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

   418

            self.Controler = self.CTR

   419

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

   420

            if not result:

   421

                self.LibraryPanel.SetController(self.Controler)

   422

                self.ProjectTree.Enable(True)

   423

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   424

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

   425

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   426

            else:

   427

                self.ResetView()

   428

                self.ShowErrorMessage(result)

   429

        else:

   430

            self.CTR = ctr

   431

            self.Controler = ctr

   432

            if ctr is not None:

   433

                self.LibraryPanel.SetController(self.Controler)

   434

                self.ProjectTree.Enable(True)

   435

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   436

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   437

        if self.EnableDebug:

   438

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   439

   440

        self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)

   441

   442

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

   443

        self.RefreshAll()

   444

        self.LogConsole.SetFocus()

   445

   446

    def RefreshTitle(self):

   447

        name = _("Beremiz")

   448

        if self.CTR is not None:

   449

            projectname = self.CTR.GetProjectName()

   450

            if self.CTR.ProjectTestModified():

   451

                projectname = "~%s~" % projectname

   452

            self.SetTitle("%s - %s" % (name, projectname))

   453

        else:

   454

            self.SetTitle(name)

   455

   456

    def StartLocalRuntime(self, taskbaricon = True):

   457

        if (self.local_runtime is None) or (self.local_runtime.exitcode is not None):

   458

            # create temporary directory for runtime working directory

   459

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   460

            # choose an arbitrary random port for runtime

   461

            self.runtime_port = int(random.random() * 1000) + 61131

   462

            # launch local runtime

   463

            self.local_runtime = ProcessLogger(self.Log,

   464

                "\"%s\" \"%s\" -p %s -i localhost %s %s"%(

   465

                    sys.executable,

   466

                    Bpath("Beremiz_service.py"),

   467

                    self.runtime_port,

   468

                    {False : "-x 0", True :"-x 1"}[taskbaricon],

   469

                    self.local_runtime_tmpdir),

   470

                no_gui=False,

   471

                timeout=500, keyword = self.local_runtime_tmpdir,

   472

                cwd = self.local_runtime_tmpdir)

   473

            self.local_runtime.spin()

   474

        return self.runtime_port

   475

   476

    def KillLocalRuntime(self):

   477

        if self.local_runtime is not None:

   478

            # shutdown local runtime

   479

            self.local_runtime.kill(gently=False)

   480

            # clear temp dir

   481

            shutil.rmtree(self.local_runtime_tmpdir)

   482

   483

            self.local_runtime = None

   484

   485

    def OnOpenWidgetInspector(self, evt):

   486

        # Activate the widget inspection tool

   487

        from wx.lib.inspection import InspectionTool

   488

        if not InspectionTool().initialized:

   489

            InspectionTool().Init()

   490

   491

        # Find a widget to be selected in the tree.  Use either the

   492

        # one under the cursor, if any, or this frame.

   493

        wnd = wx.FindWindowAtPointer()

   494

        if not wnd:

   495

            wnd = self

   496

        InspectionTool().Show(wnd, True)

   497

   498

    def OnLogConsoleFocusChanged(self, event):

   499

        self.RefreshEditMenu()

   500

        event.Skip()

   501

   502

    def OnLogConsoleUpdateUI(self, event):

   503

        self.SetCopyBuffer(self.LogConsole.GetSelectedText(), True)

   504

        event.Skip()

   505

   506

    def OnLogConsoleMarginClick(self, event):

   507

        line_idx = self.LogConsole.LineFromPosition(event.GetPosition())

   508

        wx.CallAfter(self.SearchLineForError, self.LogConsole.GetLine(line_idx))

   509

        event.Skip()

   510

   511

    def OnLogConsoleModified(self, event):

   512

        line_idx = self.LogConsole.LineFromPosition(event.GetPosition())

   513

        line = self.LogConsole.GetLine(line_idx)

   514

        if line:

   515

            result = MATIEC_ERROR_MODEL.match(line)

   516

            if result is not None:

   517

                self.LogConsole.MarkerAdd(line_idx, 0)

   518

        event.Skip()

   519

   520

    def SearchLineForError(self, line):

   521

        if self.CTR is not None:

   522

            result = MATIEC_ERROR_MODEL.match(line)

   523

            if result is not None:

   524

                first_line, first_column, last_line, last_column, error = result.groups()

   525

                infos = self.CTR.ShowError(self.Log,

   526

                                                  (int(first_line), int(first_column)),

   527

                                                  (int(last_line), int(last_column)))

   528

   529

    ## Function displaying an Error dialog in PLCOpenEditor.