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

    28

import sys

    29

import tempfile

    30

import shutil

    31

import random

    32

import time

    33

import version

    34

    35

import util.paths as paths

    36

from types import ListType

    37

    38

beremiz_dir = paths.AbsDir(__file__)

    39

    40

    41

def Bpath(*args):

    42

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

    43

    44

    45

import wx.lib.buttons

    46

import wx.lib.statbmp

    47

import wx.stc

    48

import cPickle

    49

import types

    50

import time

    51

import re

    52

import platform

    53

import time

    54

import traceback

    55

import commands

    56

    57

from docutil import OpenHtmlFrame

    58

from editors.EditorPanel import EditorPanel

    59

from editors.Viewer import Viewer

    60

from editors.TextViewer import TextViewer

    61

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    62

from editors.DataTypeEditor import DataTypeEditor

    63

from util.MiniTextControler import MiniTextControler

    64

from util.ProcessLogger import ProcessLogger

    65

from controls.LogViewer import LogViewer

    66

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    67

from controls import EnhancedStatusBar as esb

    68

from dialogs.AboutDialog import ShowAboutDialog

    69

    70

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

    71

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    72

    73

    74

MAX_RECENT_PROJECTS = 9

    75

    76

if wx.Platform == '__WXMSW__':

    77

    faces = {

    78

        'mono': 'Courier New',

    79

        'size': 8,

    80

    }

    81

else:

    82

    faces = {

    83

        'mono': 'Courier',

    84

        'size': 10,

    85

    }

    86

    87

from threading import Lock, Timer, currentThread

    88

MainThread = currentThread().ident

    89

REFRESH_PERIOD = 0.1

    90

from time import time as gettime

    91

    92

    93

class LogPseudoFile:

    94

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

    95

    def __init__(self, output, risecall):

    96

        self.red_white = 1

    97

        self.red_yellow = 2

    98

        self.black_white = wx.stc.STC_STYLE_DEFAULT

    99

        self.output = output

   100

        self.risecall = risecall

   101

        # to prevent rapid fire on rising log panel

   102

        self.rising_timer = 0

   103

        self.lock = Lock()

   104

        self.YieldLock = Lock()

   105

        self.RefreshLock = Lock()

   106

        self.TimerAccessLock = Lock()

   107

        self.stack = []

   108

        self.LastRefreshTime = gettime()

   109

        self.LastRefreshTimer = None

   110

   111

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

   112

        if self.lock.acquire():

   113

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

   114

            self.lock.release()

   115

            current_time = gettime()

   116

            self.TimerAccessLock.acquire()

   117

            if self.LastRefreshTimer:

   118

                self.LastRefreshTimer.cancel()

   119

                self.LastRefreshTimer = None

   120

            self.TimerAccessLock.release()

   121

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

   122

                self._should_write()

   123

            else:

   124

                self.TimerAccessLock.acquire()

   125

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

   126

                self.LastRefreshTimer.start()

   127

                self.TimerAccessLock.release()

   128

   129

    def _timer_expired(self):

   130

        if self.RefreshLock.acquire(False):

   131

            self._should_write()

   132

        else:

   133

            self.TimerAccessLock.acquire()

   134

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

   135

            self.LastRefreshTimer.start()

   136

            self.TimerAccessLock.release()

   137

   138

    def _should_write(self):

   139

        wx.CallAfter(self._write)

   140

        if MainThread == currentThread().ident:

   141

            app = wx.GetApp()

   142

            if app is not None:

   143

                if self.YieldLock.acquire(0):

   144

                    app.Yield()

   145

                    self.YieldLock.release()

   146

   147

    def _write(self):

   148

        if self.output:

   149

            self.output.Freeze()

   150

            self.lock.acquire()

   151

            for s, style in self.stack:

   152

                if style is None:

   153

                    style = self.black_white

   154

                if style != self.black_white:

   155

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

   156

   157

                # Temporary deactivate read only mode on StyledTextCtrl for

   158

                # adding text. It seems that text modifications, even

   159

                # programmatically, are disabled in StyledTextCtrl when read

   160

                # only is active

   161

                start_pos = self.output.GetLength()

   162

                self.output.SetReadOnly(False)

   163

                self.output.AppendText(s)

   164

                self.output.SetReadOnly(True)

   165

                text_len = self.output.GetLength() - start_pos

   166

   167

                if style != self.black_white:

   168

                    self.output.SetStyling(text_len, style)

   169

            self.stack = []

   170

            self.lock.release()

   171

            self.output.Thaw()

   172

            self.LastRefreshTime = gettime()

   173

            try:

   174

                self.RefreshLock.release()

   175

            except:

   176

                pass

   177

            newtime = time.time()

   178

            if newtime - self.rising_timer > 1:

   179

                self.risecall(self.output)

   180

            self.rising_timer = newtime

   181

   182

    def write_warning(self, s):

   183

        self.write(s, self.red_white)

   184

   185

    def write_error(self, s):

   186

        self.write(s, self.red_yellow)

   187

   188

    def writeyield(self, s):

   189

        self.write(s)

   190

        wx.GetApp().Yield()

   191

   192

    def flush(self):

   193

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   194

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

   195

        # disabled in StyledTextCtrl when read only is active

   196

        self.output.SetReadOnly(False)

   197

        self.output.SetText("")

   198

        self.output.SetReadOnly(True)

   199

   200

    def isatty(self):

   201

        return False

   202

   203

   204

ID_FILEMENURECENTPROJECTS = wx.NewId()

   205

   206

from IDEFrame import TITLE,\

   207

                     EDITORTOOLBAR,\

   208

                     FILEMENU,\

   209

                     EDITMENU,\

   210

                     DISPLAYMENU,\

   211

                     PROJECTTREE,\

   212

                     POUINSTANCEVARIABLESPANEL,\

   213

                     LIBRARYTREE,\

   214

                     SCALING,\

   215

                     PAGETITLES,\

   216

                     IDEFrame, AppendMenu,\

   217

                     EncodeFileSystemPath, DecodeFileSystemPath

   218

from util.BitmapLibrary import GetBitmap

   219

   220

   221

class Beremiz(IDEFrame):

   222

   223

    def _init_utils(self):

   224

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

   225

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

   226

   227

        IDEFrame._init_utils(self)

   228

   229

    def _init_coll_FileMenu_Items(self, parent):

   230

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

   231

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

   232

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

   233

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

   234

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

   235

        parent.AppendSeparator()

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

        parent.AppendSeparator()

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

        parent.AppendSeparator()

   252

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

   253

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

   254

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

   266

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

   267

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

   268

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

   269

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

   270

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

   271

   272

    def _RecursiveAddMenuItems(self, menu, items):

   273

        for name, text, help, children in items:

   274

            new_id = wx.NewId()

   275

            if len(children) > 0:

   276

                new_menu = wx.Menu(title='')

   277

                menu.AppendMenu(new_id, text, new_menu)

   278

                self._RecursiveAddMenuItems(new_menu, children)

   279

            else:

   280

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

   281

                       kind=wx.ITEM_NORMAL, text=text)

   282

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

   283

                          id=new_id)

   284

   285

    def _init_coll_AddMenu_Items(self, parent):

   286

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   287

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   288

   289

    def _init_coll_HelpMenu_Items(self, parent):

   290

        def handler(event):

   291

            return wx.MessageBox(

   292

                version.GetCommunityHelpMsg(),

   293

                _(u'Community support'),

   294

                wx.OK | wx.ICON_INFORMATION)

   295

   296

        id = wx.NewId()

   297

        parent.Append(help='', id=id, kind=wx.ITEM_NORMAL, text=_(u'Community support'))

   298

        self.Bind(wx.EVT_MENU, handler, id=id)

   299

   300

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

   301

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

   302

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

   303

   304

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   305

        parent.SetFieldsCount(3)

   306

   307

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

   308

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

   309

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

   310

   311

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

   312

   313

    def _init_ctrls(self, prnt):

   314

        IDEFrame._init_ctrls(self, prnt)

   315

   316

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   317

   318

        inspectorID = wx.NewId()

   319

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

   320

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

   321

   322

        keyID = wx.NewId()

   323

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

   324

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

   325

   326

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

   327

                                 ("Run",      wx.WXK_F5),

   328

                                 ("Transfer", wx.WXK_F6),

   329

                                 ("Connect",  wx.WXK_F7),

   330

                                 ("Build",    wx.WXK_F11)]:

   331

            def OnMethodGen(obj, meth):

   332

                def OnMethod(evt):

   333

                    if obj.CTR is not None:

   334

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

   335

                    wx.CallAfter(self.RefreshStatusToolBar)

   336

                return OnMethod

   337

            newid = wx.NewId()

   338

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

   339

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

   340

   341

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   342

   343

        self.LogConsole = CustomStyledTextCtrl(

   344

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

   345

                  size=wx.Size(0, 0))

   346

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

   347

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

   348

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

   349

        self.LogConsole.SetReadOnly(True)

   350

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

   351

   352

        # Define Log Console styles

   353

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

   354

        self.LogConsole.StyleClearAll()

   355

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

   356

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

   357

   358

        # Define Log Console markers

   359

        self.LogConsole.SetMarginSensitive(1, True)

   360

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

   361

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

   362

   363

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

   364

   365

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

   366

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

   367

   368

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

   369

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

   370

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

   371

   372

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

   373

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

   374

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

   375

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

   376

   377

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

   378

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

   379

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

   380

        StatusToolBar.Realize()

   381

        self.Panes["StatusToolBar"] = StatusToolBar

   382

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

   383

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

   384

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

   385

                  LeftDockable(False).RightDockable(False))

   386

   387

        self.AUIManager.Update()

   388

   389

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

   390

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   391

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

   392

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

   393

        self.ProgressStatusBar.Hide()

   394

        self.SetStatusBar(self.ConnectionStatusBar)

   395

   396

    def __init_execute_path(self):

   397

        if os.name == 'nt':

   398

            # on windows, desktop shortcut launches Beremiz.py

   399

            # with working dir set to mingw/bin.

   400

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

   401

            # commands invoked by build process by default are

   402

            # found here.

   403

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

   404

   405

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

   406

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

   407

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

   408

        self.__init_execute_path()

   409

   410

        IDEFrame.__init__(self, parent, debug)

   411

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

   412

   413

        self.local_runtime = None

   414

        self.runtime_port = None

   415

        self.local_runtime_tmpdir = None

   416

   417

        self.LastPanelSelected = None

   418

   419

        # Define Tree item icon list

   420

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

   421

        self.LocationImageDict = {}

   422

   423

        # Icons for location items

   424

        for imgname, itemtype in [

   431

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

   432

   433

        # Icons for other items

   434

        for imgname, itemtype in [

   435

            ("Extension", ITEM_CONFNODE)]:

   436

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

   437

   438

        if projectOpen is not None:

   439

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   440

   441

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

   442

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

   443

            self.Controler = self.CTR

   444

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

   445

            if not result:

   446

                self.LibraryPanel.SetController(self.Controler)

   447

                self.ProjectTree.Enable(True)

   448

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   449

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

   450

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   451

            else:

   452

                self.ResetView()

   453

                self.ShowErrorMessage(result)

   454

        else:

   455

            self.CTR = ctr

   456

            self.Controler = ctr

   457

            if ctr is not None:

   458

                self.LibraryPanel.SetController(self.Controler)

   459

                self.ProjectTree.Enable(True)

   460

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   461

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   462

        if self.EnableDebug:

   463

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   464

   465

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

   466

   467

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

   468

        self.RefreshAll()

   469

        self.LogConsole.SetFocus()

   470

   471

    def RefreshTitle(self):

   472

        name = _("Beremiz")

   473

        if self.CTR is not None:

   474

            projectname = self.CTR.GetProjectName()

   475

            if self.CTR.ProjectTestModified():

   476

                projectname = "~%s~" % projectname

   477

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

   478

        else:

   479

            self.SetTitle(name)

   480

   481

    def StartLocalRuntime(self, taskbaricon=True):

   482

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

   483

            # create temporary directory for runtime working directory

   484

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   485

            # choose an arbitrary random port for runtime

   486

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

   487

            # launch local runtime

   488

            self.local_runtime = ProcessLogger(self.Log,

   489

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

   490

                    sys.executable,

   491

                    Bpath("Beremiz_service.py"),

   492

                    self.runtime_port,

   493

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

   494

                    self.local_runtime_tmpdir),

   495

                no_gui=False,

   496

                timeout=500, keyword=self.local_runtime_tmpdir,

   497

                cwd=self.local_runtime_tmpdir)

   498

            self.local_runtime.spin()

   499

        return self.runtime_port

   500

   501

    def KillLocalRuntime(self):

   502

        if self.local_runtime is not None:

   503

            # shutdown local runtime

   504

            self.local_runtime.kill(gently=False)

   505

            # clear temp dir

   506

            shutil.rmtree(self.local_runtime_tmpdir)

   507

   508

            self.local_runtime = None

   509

   510

    def OnOpenWidgetInspector(self, evt):

   511

        # Activate the widget inspection tool

   512

        from wx.lib.inspection import InspectionTool

   513

        if not InspectionTool().initialized:

   514

            InspectionTool().Init()

   515

   516

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

   517

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

   518

        wnd = wx.FindWindowAtPointer()

   519

        if not wnd:

   520

            wnd = self