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

    34

from types import ListType

    35

    37

    38

def Bpath(*args):

    39

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

    40

    41

    42

    43

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

    44

import cPickle

    45

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

    46

    47

from docutil import OpenHtmlFrame

    48

from editors.EditorPanel import EditorPanel

    49

from editors.Viewer import Viewer

    50

from editors.TextViewer import TextViewer

    51

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    52

from editors.DataTypeEditor import DataTypeEditor

    53

from util.MiniTextControler import MiniTextControler

    54

from util.ProcessLogger import ProcessLogger

    55

from controls.LogViewer import LogViewer

    56

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    57

from controls import EnhancedStatusBar as esb

    58

from dialogs.AboutDialog import ShowAboutDialog

    59

    60

from PLCControler import LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY, ITEM_PROJECT, ITEM_RESOURCE

    61

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    62

    63

    64

MAX_RECENT_PROJECTS = 9

    65

    66

if wx.Platform == '__WXMSW__':

    67

    faces = {

    68

        'mono' : 'Courier New',

    69

        'size' : 8,

    70

    }

    71

else:

    72

    faces = {

    73

        'mono' : 'Courier',

    74

        'size' : 10,

    75

    }

    76

    77

from threading import Lock,Timer,currentThread

    78

MainThread = currentThread().ident

    79

REFRESH_PERIOD = 0.1

    80

from time import time as gettime

    81

class LogPseudoFile:

    82

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

    83

    def __init__(self, output, risecall):

    84

        self.red_white = 1

    85

        self.red_yellow = 2

    86

        self.black_white = wx.stc.STC_STYLE_DEFAULT

    87

        self.output = output

    88

        self.risecall = risecall

    89

        # to prevent rapid fire on rising log panel

    90

        self.rising_timer = 0

    91

        self.lock = Lock()

    92

        self.YieldLock = Lock()

    93

        self.RefreshLock = Lock()

    94

        self.TimerAccessLock = Lock()

    95

        self.stack = []

    96

        self.LastRefreshTime = gettime()

    97

        self.LastRefreshTimer = None

    98

    99

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

   100

        if self.lock.acquire():

   101

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

   102

            self.lock.release()

   103

            current_time = gettime()

   104

            self.TimerAccessLock.acquire()

   105

            if self.LastRefreshTimer:

   106

                self.LastRefreshTimer.cancel()

   107

                self.LastRefreshTimer=None

   108

            self.TimerAccessLock.release()

   109

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

   110

                self._should_write()

   111

            else:

   112

                self.TimerAccessLock.acquire()

   113

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

   114

                self.LastRefreshTimer.start()

   115

                self.TimerAccessLock.release()

   116

   117

    def _timer_expired(self):

   118

        if self.RefreshLock.acquire(False):

   119

            self._should_write()

   120

        else:

   121

            self.TimerAccessLock.acquire()

   122

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

   123

            self.LastRefreshTimer.start()

   124

            self.TimerAccessLock.release()

   125

   126

    def _should_write(self):

   127

        wx.CallAfter(self._write)

   128

        if MainThread == currentThread().ident:

   129

            app = wx.GetApp()

   130

            if app is not None:

   131

                if self.YieldLock.acquire(0):

   132

                    app.Yield()

   133

                    self.YieldLock.release()

   134

   135

    def _write(self):

   136

        if self.output :

   137

            self.output.Freeze()

   138

            self.lock.acquire()

   139

            for s, style in self.stack:

   140

                if style is None : style=self.black_white

   141

                if style != self.black_white:

   142

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

   143

   144

                # Temporary deactivate read only mode on StyledTextCtrl for

   145

                # adding text. It seems that text modifications, even

   146

                # programmatically, are disabled in StyledTextCtrl when read

   147

                # only is active

   148

                start_pos = self.output.GetLength()

   149

                self.output.SetReadOnly(False)

   150

                self.output.AppendText(s)

   151

                self.output.SetReadOnly(True)

   152

                text_len = self.output.GetLength() - start_pos

   153

   154

                if style != self.black_white:

   155

                    self.output.SetStyling(text_len, style)

   156

            self.stack = []

   157

            self.lock.release()

   158

            self.output.Thaw()

   159

            self.LastRefreshTime = gettime()

   160

            try:

   161

                self.RefreshLock.release()

   162

            except:

   163

                pass

   164

            newtime = time.time()

   165

            if newtime - self.rising_timer > 1:

   166

                self.risecall(self.output)

   167

            self.rising_timer = newtime

   168

   169

    def write_warning(self, s):

   170

        self.write(s,self.red_white)

   171

   172

    def write_error(self, s):

   173

        self.write(s,self.red_yellow)

   174

   175

    def writeyield(self, s):

   176

        self.write(s)

   177

        wx.GetApp().Yield()

   178

   179

    def flush(self):

   180

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   181

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

   182

        # disabled in StyledTextCtrl when read only is active

   183

        self.output.SetReadOnly(False)

   184

        self.output.SetText("")

   185

        self.output.SetReadOnly(True)

   186

   187

    def isatty(self):

   188

        return False

   189

   190

ID_FILEMENURECENTPROJECTS = wx.NewId()

   191

   192

from IDEFrame import TITLE,\

   193

                     EDITORTOOLBAR,\

   194

                     FILEMENU,\

   195

                     EDITMENU,\

   196

                     DISPLAYMENU,\

   197

                     PROJECTTREE,\

   198

                     POUINSTANCEVARIABLESPANEL,\

   199

                     LIBRARYTREE,\

   200

                     SCALING,\

   201

                     PAGETITLES,\

   202

                     IDEFrame, AppendMenu,\

   203

                     EncodeFileSystemPath, DecodeFileSystemPath

   204

from util.BitmapLibrary import GetBitmap

   205

   206

class Beremiz(IDEFrame):

   207

   208

    def _init_utils(self):

   209

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

   210

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

   211

   212

        IDEFrame._init_utils(self)

   213

   214

    def _init_coll_FileMenu_Items(self, parent):

   215

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

   216

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

   217

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

   218

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

   219

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

   220

        parent.AppendSeparator()

   221

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

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

        parent.AppendSeparator()

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

        parent.AppendSeparator()

   237

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

   238

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

   239

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

   251

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

   252

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

   253

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

   254

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

   255

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

   256

   257

    def _RecursiveAddMenuItems(self, menu, items):

   258

        for name, text, help, children in items:

   259

            new_id = wx.NewId()

   260

            if len(children) > 0:

   261

                new_menu = wx.Menu(title='')

   262

                menu.AppendMenu(new_id, text, new_menu)

   263

                self._RecursiveAddMenuItems(new_menu, children)

   264

            else:

   265

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

   266

                       kind=wx.ITEM_NORMAL, text=text)

   267

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

   268

                          id=new_id)

   269

   270

    def _init_coll_AddMenu_Items(self, parent):

   271

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   272

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   273

   274

    def _init_coll_HelpMenu_Items(self, parent):

   275

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

   276

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

   277

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

   278

   279

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   280

        parent.SetFieldsCount(3)

   281

   282

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

   283

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

   284

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

   285

   286

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

   287

   288

    def _init_ctrls(self, prnt):

   289

        IDEFrame._init_ctrls(self, prnt)

   290

   291

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   292

   293

        inspectorID = wx.NewId()

   294

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

   295

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

   296

   297

        keyID = wx.NewId()

   298

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

   299

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

   300

   301

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

   302

                                ("Run",      wx.WXK_F5),

   303

                                ("Transfer", wx.WXK_F6),

   304

                                ("Connect",  wx.WXK_F7),

   305

                                ("Build",    wx.WXK_F11)]:

   306

            def OnMethodGen(obj,meth):

   307

                def OnMethod(evt):

   308

                    if obj.CTR is not None:

   309

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

   310

                    wx.CallAfter(self.RefreshStatusToolBar)

   311

                return OnMethod

   312

            newid = wx.NewId()

   313

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

   314

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

   315

   316

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   317

   318

        self.LogConsole = CustomStyledTextCtrl(

   319

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

   320

                  size=wx.Size(0, 0))

   321

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

   322

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

   323

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

   324

        self.LogConsole.SetReadOnly(True)

   325

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

   326

   327

        # Define Log Console styles

   328

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

   329

        self.LogConsole.StyleClearAll()

   330

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

   331

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

   332

   333

        # Define Log Console markers

   334

        self.LogConsole.SetMarginSensitive(1, True)

   335

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

   336

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

   337

   338

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

   339

   340

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

   341

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

   342

   343

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

   344

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

   345

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

   346

   347

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

   348

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

   349

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

   350

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

   351

   352

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

   353

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

   354

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

   355

        StatusToolBar.Realize()

   356

        self.Panes["StatusToolBar"] = StatusToolBar

   357

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

   358

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

   359

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

   360

                  LeftDockable(False).RightDockable(False))

   361

   362

        self.AUIManager.Update()

   363

   364

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

   365

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   366

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

   367

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

   368

        self.ProgressStatusBar.Hide()

   369

        self.SetStatusBar(self.ConnectionStatusBar)

   370

   371

    def __init_execute_path(self):

   372

        if os.name == 'nt':

   373

            # on windows, desktop shortcut launches Beremiz.py

   374

            # with working dir set to mingw/bin.

   375

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

   376

            # commands invoked by build process by default are

   377

            # found here.

   378

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

   379

   380

   381

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

   382

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

   383

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

   384

        self.__init_execute_path()

   385

   386

        IDEFrame.__init__(self, parent, debug)

   387

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

   388

   389

        self.local_runtime = None

   390

        self.runtime_port = None

   391

        self.local_runtime_tmpdir = None

   392

   393

        self.LastPanelSelected = None

   394

   395

        # Define Tree item icon list

   396

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

   397

        self.LocationImageDict = {}

   398

   399

        # Icons for location items

   400

        for imgname, itemtype in [

   401

            ("CONFIGURATION", LOCATION_CONFNODE),

   402

            ("RESOURCE",      LOCATION_MODULE),

   403

            ("PROGRAM",       LOCATION_GROUP),

   404

            ("VAR_INPUT",     LOCATION_VAR_INPUT),

   405

            ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   406

            ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   407

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

   408

   409

        # Icons for other items

   410

        for imgname, itemtype in [

   411

            ("Extension", ITEM_CONFNODE)]:

   412

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

   413

   414

        if projectOpen is not None:

   415

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   416

   417

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

   418

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

   419

            self.Controler = self.CTR

   420

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

   421

            if not result:

   422

                self.LibraryPanel.SetController(self.Controler)

   423

                self.ProjectTree.Enable(True)

   424

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   425

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

   426

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   427

            else:

   428

                self.ResetView()

   429

                self.ShowErrorMessage(result)

   430

        else:

   431

            self.CTR = ctr

   432

            self.Controler = ctr

   433

            if ctr is not None:

   434

                self.LibraryPanel.SetController(self.Controler)

   435

                self.ProjectTree.Enable(True)

   436

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   437

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   438

        if self.EnableDebug:

   439

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   440

   441

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

   442

   443

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

   444

        self.RefreshAll()

   445

        self.LogConsole.SetFocus()

   446

   447

    def RefreshTitle(self):

   448

        name = _("Beremiz")

   449

        if self.CTR is not None:

   450

            projectname = self.CTR.GetProjectName()

   451

            if self.CTR.ProjectTestModified():

   452

                projectname = "~%s~" % projectname

   453

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

   454

        else:

   455

            self.SetTitle(name)

   456

   457

    def StartLocalRuntime(self, taskbaricon = True):

   458

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

   459

            # create temporary directory for runtime working directory

   460

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   461

            # choose an arbitrary random port for runtime

   462

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

   463

            # launch local runtime

   464

            self.local_runtime = ProcessLogger(self.Log,

   465

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

   466

                    sys.executable,

   467

                    Bpath("Beremiz_service.py"),

   468

                    self.runtime_port,

   469

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

   470

                    self.local_runtime_tmpdir),

   471

                no_gui=False,

   472

                timeout=500, keyword = self.local_runtime_tmpdir,

   473

                cwd = self.local_runtime_tmpdir)

   474

            self.local_runtime.spin()

   475

        return self.runtime_port

   476

   477

    def KillLocalRuntime(self):

   478

        if self.local_runtime is not None:

   479

            # shutdown local runtime

   480

            self.local_runtime.kill(gently=False)

   481

            # clear temp dir

   482

            shutil.rmtree(self.local_runtime_tmpdir)

   483

   484

            self.local_runtime = None

   485

   486

    def OnOpenWidgetInspector(self, evt):

   487

        # Activate the widget inspection tool

   488

        from wx.lib.inspection import InspectionTool

   489

        if not InspectionTool().initialized:

   490

            InspectionTool().Init()

   491

   492

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

   493

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

   494

        wnd = wx.FindWindowAtPointer()

   495

        if not wnd:

   496

            wnd = self

   497

        InspectionTool().Show(wnd, True)

   498

   499

    def OnLogConsoleFocusChanged(self, event):

   500

        self.RefreshEditMenu()

   501

        event.Skip()

   502

   503

    def OnLogConsoleUpdateUI(self, event):

   504

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

   505

        event.Skip()

   506

   507

    def OnLogConsoleMarginClick(self, event):

   508

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

   509

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

   510

        event.Skip()

   511

   512

    def OnLogConsoleModified(self, event):

   513

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

   514

        line = self.LogConsole.GetLine(line_idx)

   515

        if line:

   516

            result = MATIEC_ERROR_MODEL.match(line)

   517

            if result is not None:

   518

                self.LogConsole.MarkerAdd(line_idx, 0)

   519

        event.Skip()

   520

   521

    def SearchLineForError(self, line):

   522

        if self.CTR is not None:

   523

            result = MATIEC_ERROR_MODEL.match(line)

   524

            if result is not None:

   525

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

   526

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

   527

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

   528

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

   529