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

    AppendMenu,\

    85

    EncodeFileSystemPath, \

    86

    DecodeFileSystemPath

    87

    88

    89

beremiz_dir = paths.AbsDir(__file__)

    90

    91

    92

def Bpath(*args):

    93

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

    94

    95

    96

MAX_RECENT_PROJECTS = 9

    97

    98

    99

if wx.Platform == '__WXMSW__':

   100

    faces = {

   101

        'mono': 'Courier New',

   102

        'size': 8,

   103

    }

   104

else:

   105

    faces = {

   106

        'mono': 'Courier',

   107

        'size': 10,

   108

    }

   109

   110

   111

MainThread = currentThread().ident

   112

REFRESH_PERIOD = 0.1

   113

   114

   115

class LogPseudoFile(object):

   116

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

   117

    def __init__(self, output, risecall):

   118

        self.red_white = 1

   119

        self.red_yellow = 2

   120

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   121

        self.output = output

   122

        self.risecall = risecall

   123

        # to prevent rapid fire on rising log panel

   124

        self.rising_timer = 0

   125

        self.lock = Lock()

   126

        self.YieldLock = Lock()

   127

        self.RefreshLock = Lock()

   128

        self.TimerAccessLock = Lock()

   129

        self.stack = []

   130

        self.LastRefreshTime = gettime()

   131

        self.LastRefreshTimer = None

   132

   133

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

   134

        if self.lock.acquire():

   135

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

   136

            self.lock.release()

   137

            current_time = gettime()

   138

            self.TimerAccessLock.acquire()

   139

            if self.LastRefreshTimer:

   140

                self.LastRefreshTimer.cancel()

   141

                self.LastRefreshTimer = None

   142

            self.TimerAccessLock.release()

   143

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

   144

                self._should_write()

   145

            else:

   146

                self.TimerAccessLock.acquire()

   147

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

   148

                self.LastRefreshTimer.start()

   149

                self.TimerAccessLock.release()

   150

   151

    def _timer_expired(self):

   152

        if self.RefreshLock.acquire(False):

   153

            self._should_write()

   154

        else:

   155

            self.TimerAccessLock.acquire()

   156

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

   157

            self.LastRefreshTimer.start()

   158

            self.TimerAccessLock.release()

   159

   160

    def _should_write(self):

   161

        app = wx.GetApp()

   162

        if app is not None:

   163

            wx.CallAfter(self._write)

   164

   165

        if MainThread == currentThread().ident:

   166

            if app is not None:

   167

                if self.YieldLock.acquire(0):

   168

                    app.Yield()

   169

                    self.YieldLock.release()

   170

   171

    def _write(self):

   172

        if self.output:

   173

            self.output.Freeze()

   174

            self.lock.acquire()

   175

            for s, style in self.stack:

   176

                if style is None:

   177

                    style = self.black_white

   178

                if style != self.black_white:

   179

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

   180

   181

                # Temporary deactivate read only mode on StyledTextCtrl for

   182

                # adding text. It seems that text modifications, even

   183

                # programmatically, are disabled in StyledTextCtrl when read

   184

                # only is active

   185

                start_pos = self.output.GetLength()

   186

                self.output.SetReadOnly(False)

   187

                self.output.AppendText(s)

   188

                self.output.SetReadOnly(True)

   189

                text_len = self.output.GetLength() - start_pos

   190

   191

                if style != self.black_white:

   192

                    self.output.SetStyling(text_len, style)

   193

            self.stack = []

   194

            self.lock.release()

   195

            self.output.Thaw()

   196

            self.LastRefreshTime = gettime()

   197

            try:

   198

                self.RefreshLock.release()

   199

            except Exception:

   200

                pass

   201

            newtime = time.time()

   202

            if newtime - self.rising_timer > 1:

   203

                self.risecall(self.output)

   204

            self.rising_timer = newtime

   205

   206

    def write_warning(self, s):

   207

        self.write(s, self.red_white)

   208

   209

    def write_error(self, s):

   210

        self.write(s, self.red_yellow)

   211

   212

    def flush(self):

   213

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   214

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

   215

        # disabled in StyledTextCtrl when read only is active

   216

        self.output.SetReadOnly(False)

   217

        self.output.SetText("")

   218

        self.output.SetReadOnly(True)

   219

   220

    def isatty(self):

   221

        return False

   222

   223

   224

ID_FILEMENURECENTPROJECTS = wx.NewId()

   225

   226

   227

class Beremiz(IDEFrame):

   228

   229

    def _init_utils(self):

   230

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

   231

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

   232

   233

        IDEFrame._init_utils(self)

   234

   235

    def _init_coll_FileMenu_Items(self, parent):

   236

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

   237

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

   238

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

   239

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

   240

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

   241

        parent.AppendSeparator()

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

        parent.AppendSeparator()

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

        parent.AppendSeparator()

   258

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

   259

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

   260

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

   272

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

   273

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

   274

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

   275

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

   276

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

   277

   278

    def _RecursiveAddMenuItems(self, menu, items):

   279

        for name, text, help, children in items:

   280

            new_id = wx.NewId()

   281

            if len(children) > 0:

   282

                new_menu = wx.Menu(title='')

   283

                menu.AppendMenu(new_id, text, new_menu)

   284

                self._RecursiveAddMenuItems(new_menu, children)

   285

            else:

   286

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

   287

                           kind=wx.ITEM_NORMAL, text=text)

   288

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

   289

                          id=new_id)

   290

   291

    def _init_coll_AddMenu_Items(self, parent):

   292

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   293

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   294

   295

    def _init_coll_HelpMenu_Items(self, parent):

   296

        def handler(event):

   297

            return wx.MessageBox(

   298

                version.GetCommunityHelpMsg(),

   299

                _(u'Community support'),

   300

                wx.OK | wx.ICON_INFORMATION)

   301

   302

        id = wx.NewId()

   303

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

   304

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

   305

   306

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

   307

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

   308

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

   309

   310

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   311

        parent.SetFieldsCount(3)

   312

   313

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

   314

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

   315

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

   316

   317

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

   318

   319

    def _init_ctrls(self, prnt):

   320

        IDEFrame._init_ctrls(self, prnt)

   321

   322

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   323

   324

        inspectorID = wx.NewId()

   325

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

   326

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

   327

   328

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

   329

                                 ("Run",      wx.WXK_F5),

   330

                                 ("Transfer", wx.WXK_F6),

   331

                                 ("Connect",  wx.WXK_F7),

   332

                                 ("Build",    wx.WXK_F11)]:

   333

            def OnMethodGen(obj, meth):

   334

                def OnMethod(evt):

   335

                    if obj.CTR is not None:

   336

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

   337

                    wx.CallAfter(self.RefreshStatusToolBar)

   338

                return OnMethod

   339

            newid = wx.NewId()

   340

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

   341

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

   342

   343

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   344

   345

        self.LogConsole = CustomStyledTextCtrl(

   346

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

   347

            size=wx.Size(0, 0))

   348

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

   349

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

   350

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

   351

        self.LogConsole.SetReadOnly(True)

   352

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

   353

   354

        # Define Log Console styles

   355

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

   356

        self.LogConsole.StyleClearAll()

   357

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

   358

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

   359

   360

        # Define Log Console markers

   361

        self.LogConsole.SetMarginSensitive(1, True)

   362

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

   363

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

   364

   365

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

   366

   367

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

   368

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

   369

   370

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

   371

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

   372

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

   373

   374

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

   375

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

   376

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

   377

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

   378

   379

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

   380

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

   381

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

   382

        StatusToolBar.Realize()

   383

        self.Panes["StatusToolBar"] = StatusToolBar

   384

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

   385

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

   386

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

   387

                                LeftDockable(False).RightDockable(False))

   388

   389

        self.AUIManager.Update()

   390

   391

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

   392

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   393

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

   394

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

   395

        self.ProgressStatusBar.Hide()

   396

        self.SetStatusBar(self.ConnectionStatusBar)

   397

   398

    def __init_execute_path(self):

   399

        if os.name == 'nt':

   400

            # on windows, desktop shortcut launches Beremiz.py

   401

            # with working dir set to mingw/bin.

   402

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

   403

            # commands invoked by build process by default are

   404

            # found here.

   405

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

   406

   407

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

   408

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

   409

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

   410

        self.__init_execute_path()

   411

   412

        IDEFrame.__init__(self, parent, debug)

   413

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

   414

   415

        self.local_runtime = None

   416

        self.runtime_port = None

   417

        self.local_runtime_tmpdir = None

   418

   419

        self.LastPanelSelected = None

   420

   421

        # Define Tree item icon list

   422

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

   423

        self.LocationImageDict = {}

   424

   425

        # Icons for location items

   426

        for imgname, itemtype in [

   427

                ("CONFIGURATION", LOCATION_CONFNODE),

   428

                ("RESOURCE",      LOCATION_MODULE),

   429

                ("PROGRAM",       LOCATION_GROUP),

   430

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   431

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   432

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   433

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

   434

   435

        # Icons for other items

   436

        for imgname, itemtype in [

   437

                ("Extension", ITEM_CONFNODE)]:

   438

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

   439

   440

        if projectOpen is not None:

   441

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   442

   443

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

   444

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

   445

            self.Controler = self.CTR

   446

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

   447

            if not result:

   448

                self.LibraryPanel.SetController(self.Controler)

   449

                self.ProjectTree.Enable(True)

   450

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   451

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

   452

                self.RefreshAfterLoad()

   453

            else:

   454

                self.ResetView()

   455

                self.ShowErrorMessage(result)

   456

        else:

   457

            self.CTR = ctr

   458

            self.Controler = ctr

   459

            if ctr is not None:

   460

                ctr.SetAppFrame(self, self.Log)

   461

                self.LibraryPanel.SetController(self.Controler)

   462

                self.ProjectTree.Enable(True)

   463

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   464

                self.RefreshAfterLoad()

   465

        if self.EnableDebug:

   466

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   467

   468

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

   469

   470

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

   471

        self.RefreshAll()

   472

        self.LogConsole.SetFocus()

   473

   474

    def RefreshTitle(self):

   475

        name = _("Beremiz")

   476

        if self.CTR is not None:

   477

            projectname = self.CTR.GetProjectName()

   478

            if self.CTR.ProjectTestModified():

   479

                projectname = "~%s~" % projectname

   480

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

   481

        else:

   482

            self.SetTitle(name)

   483

   484

    def StartLocalRuntime(self, taskbaricon=True):

   485

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

   486

            # create temporary directory for runtime working directory

   487

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   488

            # choose an arbitrary random port for runtime

   489

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

   490

            # launch local runtime

   491

            self.local_runtime = ProcessLogger(

   492

                self.Log,

   493

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

   494

                    sys.executable,

   495

                    Bpath("Beremiz_service.py"),

   496

                    self.runtime_port,

   497

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

   498

                    self.local_runtime_tmpdir),

   499

                no_gui=False,

   500

                timeout=500, keyword=self.local_runtime_tmpdir,

   501

                cwd=self.local_runtime_tmpdir)

   502

            self.local_runtime.spin()

   503

        return self.runtime_port

   504

   505

    def KillLocalRuntime(self):

   506

        if self.local_runtime is not None:

   507

            # shutdown local runtime

   508

            self.local_runtime.kill(gently=False)

   509

            # clear temp dir

   510

            shutil.rmtree(self.local_runtime_tmpdir)

   511