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

import os

    29

import sys

    30

import tempfile

    31

import shutil

    32

import random

    33

import types

    34

import time

    35

from time import time as gettime

    36

from threading import Lock, Timer, currentThread

    37

    38

import cPickle

    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 writeyield(self, s):

   213

        self.write(s)

   214

        wx.GetApp().Yield()

   215

   216

    def flush(self):

   217

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   218

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

   219

        # disabled in StyledTextCtrl when read only is active

   220

        self.output.SetReadOnly(False)

   221

        self.output.SetText("")

   222

        self.output.SetReadOnly(True)

   223

   224

    def isatty(self):

   225

        return False

   226

   227

   228

ID_FILEMENURECENTPROJECTS = wx.NewId()

   229

   230

   231

class Beremiz(IDEFrame):

   232

   233

    def _init_utils(self):

   234

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

   235

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

   236

   237

        IDEFrame._init_utils(self)

   238

   239

    def _init_coll_FileMenu_Items(self, parent):

   240

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

   241

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

   242

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

   243

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

   244

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

   245

        parent.AppendSeparator()

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

        parent.AppendSeparator()

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

        parent.AppendSeparator()

   262

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

   263

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

   264

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

   276

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

   277

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

   278

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

   279

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

   280

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

   281

   282

    def _RecursiveAddMenuItems(self, menu, items):

   283

        for name, text, help, children in items:

   284

            new_id = wx.NewId()

   285

            if len(children) > 0:

   286

                new_menu = wx.Menu(title='')

   287

                menu.AppendMenu(new_id, text, new_menu)

   288

                self._RecursiveAddMenuItems(new_menu, children)

   289

            else:

   290

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

   291

                           kind=wx.ITEM_NORMAL, text=text)

   292

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

   293

                          id=new_id)

   294

   295

    def _init_coll_AddMenu_Items(self, parent):

   296

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   297

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   298

   299

    def _init_coll_HelpMenu_Items(self, parent):

   300

        def handler(event):

   301

            return wx.MessageBox(

   302

                version.GetCommunityHelpMsg(),

   303

                _(u'Community support'),

   304

                wx.OK | wx.ICON_INFORMATION)

   305

   306

        id = wx.NewId()

   307

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

   308

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

   309

   310

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

   311

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

   312

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

   313

   314

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   315

        parent.SetFieldsCount(3)

   316

   317

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

   318

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

   319

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

   320

   321

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

   322

   323

    def _init_ctrls(self, prnt):

   324

        IDEFrame._init_ctrls(self, prnt)

   325

   326

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   327

   328

        inspectorID = wx.NewId()

   329

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

   330

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

   331

   332

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

   333

                                 ("Run",      wx.WXK_F5),

   334

                                 ("Transfer", wx.WXK_F6),

   335

                                 ("Connect",  wx.WXK_F7),

   336

                                 ("Build",    wx.WXK_F11)]:

   337

            def OnMethodGen(obj, meth):

   338

                def OnMethod(evt):

   339

                    if obj.CTR is not None:

   340

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

   341

                    wx.CallAfter(self.RefreshStatusToolBar)

   342

                return OnMethod

   343

            newid = wx.NewId()

   344

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

   345

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

   346

   347

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   348

   349

        self.LogConsole = CustomStyledTextCtrl(

   350

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

   351

            size=wx.Size(0, 0))

   352

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

   353

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

   354

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

   355

        self.LogConsole.SetReadOnly(True)

   356

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

   357

   358

        # Define Log Console styles

   359

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

   360

        self.LogConsole.StyleClearAll()

   361

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

   362

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

   363

   364

        # Define Log Console markers

   365

        self.LogConsole.SetMarginSensitive(1, True)

   366

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

   367

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

   368

   369

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

   370

   371

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

   372

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

   373

   374

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

   375

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

   376

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

   377

   378

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

   379

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

   380

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

   381

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

   382

   383

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

   384

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

   385

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

   386

        StatusToolBar.Realize()

   387

        self.Panes["StatusToolBar"] = StatusToolBar

   388

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

   389

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

   390

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

   391

                                LeftDockable(False).RightDockable(False))

   392

   393

        self.AUIManager.Update()

   394

   395

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

   396

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   397

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

   398

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

   399

        self.ProgressStatusBar.Hide()

   400

        self.SetStatusBar(self.ConnectionStatusBar)

   401

   402

    def __init_execute_path(self):

   403

        if os.name == 'nt':

   404

            # on windows, desktop shortcut launches Beremiz.py

   405

            # with working dir set to mingw/bin.

   406

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

   407

            # commands invoked by build process by default are

   408

            # found here.

   409

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

   410

   411

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

   412

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

   413

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

   414

        self.__init_execute_path()

   415

   416

        IDEFrame.__init__(self, parent, debug)

   417

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

   418

   419

        self.local_runtime = None

   420

        self.runtime_port = None

   421

        self.local_runtime_tmpdir = None

   422

   423

        self.LastPanelSelected = None

   424

   425

        # Define Tree item icon list

   426

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

   427

        self.LocationImageDict = {}

   428

   429

        # Icons for location items

   430

        for imgname, itemtype in [

   431

                ("CONFIGURATION", LOCATION_CONFNODE),

   432

                ("RESOURCE",      LOCATION_MODULE),

   433

                ("PROGRAM",       LOCATION_GROUP),

   434

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   435

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   436

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   437

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

   438

   439

        # Icons for other items

   440

        for imgname, itemtype in [

   441

                ("Extension", ITEM_CONFNODE)]:

   442

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

   443

   444

        if projectOpen is not None:

   445

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   446

   447

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

   448

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

   449

            self.Controler = self.CTR

   450

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

   451

            if not result:

   452

                self.LibraryPanel.SetController(self.Controler)

   453

                self.ProjectTree.Enable(True)

   454

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   455

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

   456

                self.RefreshAfterLoad()

   457

            else:

   458

                self.ResetView()

   459

                self.ShowErrorMessage(result)

   460

        else:

   461

            self.CTR = ctr

   462

            self.Controler = ctr

   463

            if ctr is not None:

   464

                ctr.SetAppFrame(self, self.Log)

   465

                self.LibraryPanel.SetController(self.Controler)

   466

                self.ProjectTree.Enable(True)

   467

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   468

                self.RefreshAfterLoad()

   469

        if self.EnableDebug:

   470

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   471

   472

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

   473

   474

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

   475

        self.RefreshAll()

   476

        self.LogConsole.SetFocus()

   477

   478

    def RefreshTitle(self):

   479

        name = _("Beremiz")

   480

        if self.CTR is not None:

   481

            projectname = self.CTR.GetProjectName()

   482

            if self.CTR.ProjectTestModified():

   483

                projectname = "~%s~" % projectname

   484

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

   485

        else:

   486

            self.SetTitle(name)

   487

   488

    def StartLocalRuntime(self, taskbaricon=True):

   489

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

   490

            # create temporary directory for runtime working directory

   491

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   492

            # choose an arbitrary random port for runtime

   493

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

   494

            # launch local runtime

   495

            self.local_runtime = ProcessLogger(

   496

                self.Log,

   497

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

   498

                    sys.executable,

   499

                    Bpath("Beremiz_service.py"),

   500

                    self.runtime_port,

   501

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

   502

                    self.local_runtime_tmpdir),

   503

                no_gui=False,

   504

                timeout=500, keyword=self.local_runtime_tmpdir,

   505

                cwd=self.local_runtime_tmpdir)

   506

            self.local_runtime.spin()

   507

        return self.runtime_port

   508

   509

    def KillLocalRuntime(self):

   510

        if self.local_runtime is not None:

   511

            # shutdown local runtime